@zenera/cli 1.1.24 → 1.1.26

package/dist/meta/finetune/cost.js

@@ -0,0 +1,105 @@
+import { readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { validateProject } from "../host.js";
+export async function measure(root) {
+    return costOf(root, await validateProject({ dir: root }));
+}
+/** No `skills:` key is the whole catalog as an index, the same as the runtime. */
+export const bindingOf = (a) => a.skills ?? { discovery: 'index' };
+/** The skills a binding lets its agent load. */
+export const visibleTo = (b, entries) => entries.filter((s) => !b.allow || b.allow.includes(s.name));
+function size(root, rel) {
+    try {
+        return statSync(join(root, rel)).size;
+    }
+    catch {
+        return 0;
+    }
+}
+export function costOf(root, report) {
+    const entries = report.skills.entries;
+    const skills = Object.fromEntries(entries.map((s) => [s.name, size(root, s.path)]));
+    const alwaysRead = {};
+    const visible = {};
+    for (const a of report.agents) {
+        const binding = bindingOf(a);
+        const seen = visibleTo(binding, entries);
+        const index = binding.discovery === 'index'
+            ? seen.reduce((n, s) => n + Buffer.byteLength(`- ${s.name}: ${s.description}\n`), 0)
+            : 0;
+        const preloaded = (binding.preload ?? []).reduce((n, s) => n + (skills[s] ?? 0), 0);
+        alwaysRead[a.name] =
+            a.instructions.reduce((n, rel) => n + size(root, rel), 0) + preloaded + index;
+        visible[a.name] = seen.length;
+    }
+    const total = Object.values(alwaysRead).reduce((n, b) => n + b, 0);
+    return { alwaysRead, total, skills, visible, files: markdown(root) };
+}
+function markdown(root) {
+    const out = {};
+    let names = [];
+    try {
+        names = readdirSync(join(root, 'agents'), { recursive: true });
+    }
+    catch {
+        return out;
+    }
+    for (const name of names.sort()) {
+        if (name.endsWith('.md')) {
+            const rel = join('agents', name).split('\\').join('/');
+            out[rel] = size(root, rel);
+        }
+    }
+    return out;
+}
+export function limits(start, c) {
+    return {
+        budget: c.budget,
+        // A project that starts nearly empty still gets one apply's worth of room.
+        ceiling: Math.max(start.total + c.budget, Math.round(start.total * (1 + c.maxGrowth / 100))),
+        skillCap: c.skillCap,
+        maxSkills: c.maxSkills,
+    };
+}
+/** Every limit an edit broke, said so the next attempt can act on it; empty when none. */
+export function overLimits(before, after, l) {
+    const out = [];
+    const grew = after.total - before.total;
+    if (grew > l.budget) {
+        out.push(`what the agents always read grew by ${grew} bytes (${before.total} -> ${after.total}), over the budget of ${l.budget}`);
+    }
+    if (grew > 0 && after.total > l.ceiling) {
+        out.push(`what the agents always read is ${after.total} bytes, over the ceiling of ${l.ceiling}: past it an apply may add nothing - cut, move or extract to make room`);
+    }
+    for (const [name, bytes] of Object.entries(after.skills)) {
+        if (bytes > l.skillCap && bytes > (before.skills[name] ?? 0)) {
+            out.push(`skill ${name} holds ${bytes} bytes, over the cap of ${l.skillCap}: split it by when each part is needed`);
+        }
+    }
+    for (const [agent, n] of Object.entries(after.visible)) {
+        if (n > l.maxSkills && n > (before.visible[agent] ?? 0)) {
+            out.push(`agent ${agent} sees ${n} skills, over ${l.maxSkills}: merge skills whose descriptions overlap`);
+        }
+    }
+    return out;
+}
+/** What moved between two measures, per agent, skill and file - for a person and the next attempt. */
+export function costChanges(before, after) {
+    const rows = [];
+    const diff = (label, a, b) => {
+        for (const key of [...new Set([...Object.keys(a), ...Object.keys(b)])].sort()) {
+            const was = a[key] ?? 0;
+            const now = b[key] ?? 0;
+            if (was !== now) {
+                rows.push(`| ${label} | ${key} | ${was} | ${now} | ${now - was > 0 ? '+' : ''}${now - was} |`);
+            }
+        }
+    };
+    diff('always read', before.alwaysRead, after.alwaysRead);
+    diff('skill', before.skills, after.skills);
+    diff('file', before.files, after.files);
+    return rows.length > 0
+        ? ['| What | Name | Before | After | Change |', '| --- | --- | --- | --- | --- |', ...rows]
+        : [];
+}
+//# sourceMappingURL=cost.js.map

package/dist/meta/finetune/dataset/anchors.d.ts

@@ -0,0 +1,41 @@
+import { type Anchor } from './types.ts';
+export type Found = {
+    found: true;
+    text: string;
+    sha256: string;
+} | {
+    found: false;
+    why: 'no file' | 'not found' | 'ambiguous' | 'unreadable';
+};
+interface Heading {
+    level: number;
+    title: string;
+    path: string[];
+    /** first line, and one past the last line of its section */
+    start: number;
+    end: number;
+}
+export declare const sha256: (text: string) => string;
+/** Every ATX heading outside a code fence, with the extent of its section. */
+export declare function headingsOf(text: string): Heading[];
+/** Sorted keys, so reformatting or reordering a document is not a change. */
+export declare function canonical(value: unknown): string;
+/** One read of each file per instance: a drift check asks about many cases per file. */
+export declare class Sources {
+    #private;
+    readonly root: string;
+    constructor(root: string);
+    text(file: string): string | undefined;
+    /** Of the bytes as they are: any edit at all, even one no case sees. */
+    hash(file: string): string | undefined;
+    section(file: string, anchor: Anchor | undefined): Found;
+    /**
+     * Sections of a file no case and no ignore accounts for: headings at the
+     * levels the covered ones sit at, or the siblings of covered pointers. A
+     * section inside a covered one is part of that case, and a section around one
+     * is its context, so neither is reported.
+     */
+    uncovered(file: string, covered: readonly (Anchor | undefined)[]): Anchor[];
+}
+export {};
+//# sourceMappingURL=anchors.d.ts.map

package/dist/meta/finetune/dataset/anchors.js

@@ -0,0 +1,239 @@
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { extname, resolve } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import {} from "./types.js";
+export const sha256 = (text) => createHash('sha256').update(text).digest('hex');
+const normal = (text) => text
+    .replace(/\r\n?/g, '\n')
+    .split('\n')
+    .map((line) => line.trimEnd())
+    .join('\n')
+    .replace(/\n+$/, '');
+const title = (text) => text.replace(/\s+/g, ' ').trim();
+/** Every ATX heading outside a code fence, with the extent of its section. */
+export function headingsOf(text) {
+    const lines = text.replace(/\r\n?/g, '\n').split('\n');
+    const found = [];
+    const stack = [];
+    let fence;
+    lines.forEach((line, i) => {
+        const marker = /^ {0,3}(`{3,}|~{3,})/.exec(line);
+        if (marker) {
+            const char = marker[1][0];
+            if (!fence) {
+                fence = { char, size: marker[1].length };
+            }
+            else if (fence.char === char && marker[1].length >= fence.size) {
+                fence = undefined;
+            }
+            return;
+        }
+        if (fence) {
+            return;
+        }
+        const m = /^ {0,3}(#{1,6})(?:[ \t]+(.*?))?(?:[ \t]+#+)?[ \t]*$/.exec(line);
+        if (!m || !m[2]?.trim()) {
+            return;
+        }
+        const level = m[1].length;
+        while (stack.length > 0 && stack[stack.length - 1].level >= level) {
+            stack.pop();
+        }
+        const heading = {
+            level,
+            title: title(m[2]),
+            path: [...stack.map((h) => h.title), title(m[2])],
+            start: i,
+            end: lines.length,
+        };
+        stack.push(heading);
+        found.push(heading);
+    });
+    for (let i = 0; i < found.length; i++) {
+        const next = found.slice(i + 1).find((h) => h.level <= found[i].level);
+        found[i].end = next ? next.start : lines.length;
+    }
+    return found;
+}
+/**
+ * The last name must be the heading's own; the names before it must appear, in
+ * order, among its ancestors. So `["Query: organize my day"]` is enough while it
+ * is unique, and an author adds a parent only to tell two apart.
+ */
+function matches(path, heading) {
+    const want = path.map(title);
+    if (want[want.length - 1] !== heading.title) {
+        return false;
+    }
+    let at = 0;
+    for (const name of heading.path.slice(0, -1)) {
+        if (at < want.length - 1 && name === want[at]) {
+            at++;
+        }
+    }
+    return at === want.length - 1;
+}
+/** RFC 6901, over a parsed JSON or YAML document. */
+function follow(doc, pointer) {
+    if (pointer === '') {
+        return { ok: true, value: doc };
+    }
+    let at = doc;
+    for (const raw of pointer.slice(1).split('/')) {
+        const key = raw.replace(/~1/g, '/').replace(/~0/g, '~');
+        if (Array.isArray(at) && /^\d+$/.test(key) && Number(key) < at.length) {
+            at = at[Number(key)];
+        }
+        else if (at !== null && typeof at === 'object' && !Array.isArray(at) && key in at) {
+            at = at[key];
+        }
+        else {
+            return { ok: false };
+        }
+    }
+    return { ok: true, value: at };
+}
+const escapeKey = (key) => key.replace(/~/g, '~0').replace(/\//g, '~1');
+/** Sorted keys, so reformatting or reordering a document is not a change. */
+export function canonical(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map(canonical).join(',')}]`;
+    }
+    if (value !== null && typeof value === 'object') {
+        const keys = Object.keys(value).sort();
+        return `{${keys
+            .map((k) => `${JSON.stringify(k)}:${canonical(value[k])}`)
+            .join(',')}}`;
+    }
+    return JSON.stringify(value) ?? 'null';
+}
+/** One read of each file per instance: a drift check asks about many cases per file. */
+export class Sources {
+    root;
+    #text = new Map();
+    #headings = new Map();
+    #docs = new Map();
+    constructor(root) {
+        this.root = root;
+    }
+    text(file) {
+        if (!this.#text.has(file)) {
+            let text;
+            try {
+                text = readFileSync(resolve(this.root, file), 'utf8');
+            }
+            catch {
+                text = undefined;
+            }
+            this.#text.set(file, text);
+        }
+        return this.#text.get(file);
+    }
+    /** Of the bytes as they are: any edit at all, even one no case sees. */
+    hash(file) {
+        const text = this.text(file);
+        return text === undefined ? undefined : sha256(text);
+    }
+    #headingsOf(file, text) {
+        let found = this.#headings.get(file);
+        if (!found) {
+            found = headingsOf(text);
+            this.#headings.set(file, found);
+        }
+        return found;
+    }
+    #doc(file, text) {
+        let parsed = this.#docs.get(file);
+        if (!parsed) {
+            try {
+                const ext = extname(file).toLowerCase();
+                parsed = { ok: true, doc: ext === '.json' ? JSON.parse(text) : parseYaml(text) };
+            }
+            catch {
+                parsed = { ok: false };
+            }
+            this.#docs.set(file, parsed);
+        }
+        return parsed;
+    }
+    section(file, anchor) {
+        const text = this.text(file);
+        if (text === undefined) {
+            return { found: false, why: 'no file' };
+        }
+        if (anchor?.heading) {
+            const hits = this.#headingsOf(file, text).filter((h) => matches(anchor.heading, h));
+            if (hits.length !== 1) {
+                return { found: false, why: hits.length === 0 ? 'not found' : 'ambiguous' };
+            }
+            const lines = text.replace(/\r\n?/g, '\n').split('\n');
+            const body = normal(lines.slice(hits[0].start, hits[0].end).join('\n'));
+            return { found: true, text: body, sha256: sha256(body) };
+        }
+        if (anchor?.pointer !== undefined) {
+            const parsed = this.#doc(file, text);
+            if (!parsed.ok) {
+                return { found: false, why: 'unreadable' };
+            }
+            const hit = follow(parsed.doc, anchor.pointer);
+            if (!hit.ok) {
+                return { found: false, why: 'not found' };
+            }
+            const body = canonical(hit.value);
+            return { found: true, text: body, sha256: sha256(body) };
+        }
+        const body = normal(text);
+        return { found: true, text: body, sha256: sha256(body) };
+    }
+    /**
+     * Sections of a file no case and no ignore accounts for: headings at the
+     * levels the covered ones sit at, or the siblings of covered pointers. A
+     * section inside a covered one is part of that case, and a section around one
+     * is its context, so neither is reported.
+     */
+    uncovered(file, covered) {
+        const text = this.text(file);
+        if (text === undefined || covered.some((a) => !a?.heading && a?.pointer === undefined)) {
+            return [];
+        }
+        const out = [];
+        const paths = covered.flatMap((a) => (a?.heading ? [a.heading] : []));
+        if (paths.length > 0) {
+            const all = this.#headingsOf(file, text);
+            const hit = all.filter((h) => paths.some((p) => matches(p, h)));
+            const levels = new Set(hit.map((h) => h.level));
+            const near = (h) => hit.some((c) => c === h ||
+                (c.start <= h.start && h.start < c.end) ||
+                (h.start <= c.start && c.start < h.end));
+            for (const h of all) {
+                if (levels.has(h.level) && !near(h)) {
+                    out.push({ heading: h.path });
+                }
+            }
+        }
+        const pointers = covered.flatMap((a) => (a?.pointer ? [a.pointer] : []));
+        if (pointers.length > 0) {
+            const parsed = this.#doc(file, text);
+            const taken = new Set(pointers);
+            const parents = new Set(pointers.map((p) => p.slice(0, p.lastIndexOf('/'))));
+            for (const parent of parents) {
+                const hit = parsed.ok ? follow(parsed.doc, parent) : { ok: false };
+                if (!hit.ok || hit.value === null || typeof hit.value !== 'object') {
+                    continue;
+                }
+                const keys = Array.isArray(hit.value)
+                    ? hit.value.map((_, i) => String(i))
+                    : Object.keys(hit.value);
+                for (const key of keys) {
+                    const pointer = `${parent}/${escapeKey(key)}`;
+                    if (!taken.has(pointer)) {
+                        out.push({ pointer });
+                    }
+                }
+            }
+        }
+        return out;
+    }
+}
+//# sourceMappingURL=anchors.js.map

package/dist/meta/finetune/dataset/changes.d.ts

@@ -0,0 +1,36 @@
+import type { Proposed, ProposedRubric } from './schema.ts';
+import type { Commit, DatasetStore } from './store.ts';
+import { type By, type Case, type Manifest, type RubricItem } from './types.ts';
+export interface Plan extends Commit {
+    /** cases that were looked at and found the same */
+    unchanged: string[];
+}
+/**
+ * Rubric items keep their ids across edits, so a note saying `r3 failed` still
+ * means the same line. An explicit id wins; otherwise the same words are the
+ * same item; anything else is new.
+ */
+export declare function assignRubric(before: readonly RubricItem[], proposed: readonly ProposedRubric[]): RubricItem[];
+/**
+ * A proposal, applied. Whole by default: an active case the proposal does not
+ * name is retired. `partial` touches only the cases it names — what a refresh
+ * of a few drifted sections writes.
+ */
+export declare function planApply(store: DatasetStore, proposed: readonly Proposed[], options: {
+    partial: boolean;
+    why: string;
+    by: By;
+}): Plan;
+/** One case, changed by hand. `override` keeps the change through later re-extractions. */
+export declare function planEdit(store: DatasetStore, id: string, edit: (c: Case) => Case, options: {
+    why: string;
+    by: By;
+    override?: readonly string[];
+}): Plan;
+export declare function planStatus(store: DatasetStore, ids: readonly string[], status: Case['status'], options: {
+    why: string;
+    by: By;
+}): Plan;
+/** The ignore list changed: no case moves, so no revision; the manifest is rewritten. */
+export declare function planIgnored(store: DatasetStore, ignored: Manifest['ignored']): Plan;
+//# sourceMappingURL=changes.d.ts.map