jev-agent-tools 0.1.4 → 0.3.0

package/dist/presets/witnesses.js

@@ -0,0 +1,249 @@
+import { COVERAGE_WITNESS_LURE_MAX, WITNESS_ETALON_MIN, WITNESS_LARGE_CHARS, WITNESS_LARGE_LURE_MAX, WITNESS_LURE_MAX, } from "../constants.js";
+import { isTestFile } from "../core/diff.js";
+export function buildWitnessUnits(units, options = {}) {
+    const result = [];
+    const templates = [
+        {
+            kind: "function",
+            file: "src/slug.ts",
+            name: "slugify",
+            before: "function slugify(s) { return s.trim().toLowerCase(); }",
+            after: "function slugify(s) { const trimmed = s.trim(); return trimmed.toLowerCase(); }",
+            label: "neutral refactor",
+        },
+        {
+            kind: "function",
+            file: "src/format.ts",
+            name: "formatLine",
+            before: "function formatLine(s) { return s + '\\n'; }",
+            after: "function formatLine(s) { return s + '\\n'; }",
+            label: "unchanged function",
+        },
+    ];
+    const classes = new Set(units.map((unit) => (isTestFile(unit.file) ? "test" : unit.kind)));
+    if (options.testFilesPresent)
+        classes.add("test");
+    for (const kind of classes) {
+        if (kind === "function")
+            continue;
+        if (kind === "test")
+            templates.push({
+                kind: "file",
+                file: "test/cli.test.ts",
+                name: "cli test",
+                before: "test('flag', () => expect(parseArgs(['--legacy'])).toEqual({ mode: true }));",
+                after: "test('flag', () => expect(parseArgs(['--compat'])).toEqual({ mode: true }));",
+                label: "test that follows a rename",
+            });
+        else if (kind === "file")
+            templates.push({
+                kind,
+                file: "config/settings.json",
+                name: "settings",
+                before: '{"port":8080,"enabled":true}',
+                after: '{"enabled":true,"port":8080}',
+                label: "configuration",
+            });
+        else if (kind === "declaration")
+            templates.push({
+                kind,
+                file: "src/limits.ts",
+                name: "MAX_ITEMS",
+                before: "export const MAX_ITEMS = 1000;",
+                after: "export const MAX_ITEMS = 1_000;",
+                label: "declaration",
+            });
+        else
+            templates.push({
+                kind,
+                file: "src/render.ts",
+                name: "render",
+                before: "const value = item.name;\nreturn value;",
+                after: "const label = item.name;\nreturn label;",
+                label: `${kind} neutral rename`,
+            });
+    }
+    templates.push({
+        kind: "function",
+        file: "src/accounts.ts",
+        name: "deleteAccount",
+        before: "function deleteAccount(user, account) { if (user.role !== 'admin') throw Error('forbidden'); return db.delete(account); }",
+        after: "function deleteAccount(user, account) { return db.delete(account); }",
+        reference: "security",
+        label: "authorization removed",
+    }, {
+        kind: "function",
+        file: "src/money.ts",
+        name: "formatPrice",
+        before: "export function formatPrice(amount) { return amount.toFixed(2); }",
+        after: "export function formatMoney(amount) { return amount.toFixed(2); }",
+        reference: "compatibility",
+        label: "export renamed",
+    }, {
+        kind: "function",
+        file: "src/discount.ts",
+        name: "applyDiscount",
+        before: "function applyDiscount(price, discount) { return price - discount; }",
+        after: "function applyDiscount(price, discount) { return price + discount; }",
+        reference: "correctness",
+        label: "discount sign reversed",
+    });
+    const ids = new Set(units.map((unit) => unit.id));
+    let number = 1;
+    for (const template of templates) {
+        let unitId;
+        do {
+            unitId = `w${String(number++).padStart(3, "0")}`;
+        } while (ids.has(unitId));
+        ids.add(unitId);
+        const unit = {
+            id: unitId,
+            kind: template.kind,
+            file: template.file,
+            name: template.name,
+            exported: true,
+            before: template.before,
+            after: template.after,
+            beforeRange: { start: 1, end: template.before.split("\n").length },
+            afterRange: { start: 1, end: template.after.split("\n").length },
+        };
+        result.push({
+            unit,
+            label: template.label,
+            ...(template.reference ? { reference: template.reference } : {}),
+            limit: template.reference
+                ? WITNESS_ETALON_MIN
+                : template.before.length + template.after.length >= WITNESS_LARGE_CHARS
+                    ? WITNESS_LARGE_LURE_MAX
+                    : WITNESS_LURE_MAX,
+        });
+    }
+    return result;
+}
+/** Frozen embedded-after coverage template; independent of risk witnesses. */
+export function buildCoverageWitnessUnits(units) {
+    const templates = [
+        [
+            "normalize",
+            "src/normalize.js",
+            "export function normalize(s) { return s.trim().toLowerCase(); }",
+            "export function normalize(s) { const v = s.trim(); return v.toLowerCase(); }",
+        ],
+        [
+            "formatLine",
+            "src/format.js",
+            "export function formatLine(s) { return s + '\\n'; }",
+            "export function formatLine(s) { return s + '\\n'; }",
+        ],
+        [
+            "MAX_ITEMS",
+            "src/count.js",
+            "export const MAX_ITEMS = 1000;",
+            "export const MAX_ITEMS = 1_000;",
+        ],
+        [
+            "increment",
+            "src/increment.js",
+            "export function increment(n) { return n - 1; }",
+            "export function increment(n) { return n + 1; }",
+        ],
+        [
+            "formatPrice",
+            "src/price.js",
+            "export function formatPrice(n) { return n.toFixed(2); }",
+            "export function formatMoney(n) { return n.toFixed(2); }",
+        ],
+        [
+            "LIMIT",
+            "src/limit.js",
+            "export const LIMIT = 3;",
+            "export const LIMIT = 4;",
+        ],
+        [
+            "withinLimit",
+            "src/limit.js",
+            "export function withinLimit(n) { return n <= LIMIT; }",
+            "export function withinLimit(n) { return n <= LIMIT; }",
+        ],
+    ];
+    const ids = new Set(units.map((unit) => unit.id));
+    let number = 1;
+    return templates.map(([name, file, before, after], index) => {
+        let id;
+        do {
+            id = `w${String(number++).padStart(3, "0")}`;
+        } while (ids.has(id));
+        ids.add(id);
+        const reference = index >= 3 && index < 6;
+        return {
+            unit: {
+                id,
+                name,
+                file,
+                before,
+                after,
+                kind: name === "LIMIT" || name === "MAX_ITEMS" ? "declaration" : "function",
+                exported: true,
+                beforeRange: null,
+                afterRange: null,
+            },
+            label: name,
+            ...(reference ? { reference: "correctness" } : {}),
+            ...(name === "withinLimit" ? { evidenceOnly: true } : {}),
+            limit: reference ? WITNESS_ETALON_MIN : COVERAGE_WITNESS_LURE_MAX,
+        };
+    });
+}
+export function evaluateBatchWitnessHealth(questionIds, witnesses, judgment) {
+    const failures = [];
+    const unhealthyQuestionIds = new Map();
+    const realIds = new Set(questionIds);
+    const batches = judgment.batches ?? [
+        {
+            questionIds: [...questionIds],
+            answers: judgment.ok ? judgment.answers : {},
+        },
+    ];
+    for (const batch of batches) {
+        if (!batch.questionIds.some((id) => realIds.has(id)))
+            continue;
+        const unavailable = [];
+        const reasons = [];
+        for (const witness of witnesses) {
+            const answer = batch.answers[witness.id];
+            const dimension = witness.dimension ? ` ${witness.dimension}` : "";
+            if (!judgment.ok)
+                unavailable.push(judgment.error);
+            else if (answer?.type !== "bool")
+                unavailable.push(`${witness.label}${dimension} unjudged${answer?.type === "unjudged" ? `: ${answer.reason}` : ""}`);
+            else if (witness.expected === "no"
+                ? answer.p > witness.limit
+                : answer.p < witness.limit)
+                reasons.push(`${witness.expected === "no" ? "decoy" : "reference"} "${witness.label}"${dimension} at ${answer.p.toFixed(2)} (limit ${witness.limit})`);
+        }
+        if (!reasons.length && !unavailable.length)
+            continue;
+        const batchFailures = [];
+        if (reasons.length)
+            batchFailures.push({
+                fact: `set-up check failed: ${reasons.join("; ")}`,
+                next: "rerun with base= a nearer ref and complete before/after units",
+            });
+        if (unavailable.length)
+            batchFailures.push({
+                fact: `witness control unavailable: ${[...new Set(unavailable)].join("; ")}`,
+                next: "check Jev availability or raise max_calls",
+            });
+        failures.push(...batchFailures);
+        const reason = batchFailures.map((failure) => failure.fact).join("; ");
+        for (const id of batch.questionIds)
+            if (realIds.has(id))
+                unhealthyQuestionIds.set(id, reason);
+    }
+    return {
+        healthy: failures.length === 0,
+        failures,
+        controls: failures,
+        unhealthyQuestionIds,
+    };
+}

package/dist/render.js

@@ -0,0 +1,114 @@
+function renderLine(line) {
+    switch (line.type) {
+        case "state":
+            return `state: ${line.files} files · integrity ${line.integrity}${line.warnings.length ? ` · ${line.warnings.length} warnings: ${line.warnings.join("; ")}` : ""}`;
+        case "answer":
+            return `${line.band === "verdict" ? "" : `${line.band}  `}${line.uncalibrated ? "uncalibrated  " : ""}${line.label} = ${line.value.head} (${line.value.p})${line.orderDependent ? " · order-dependent" : ""}${line.reason ? ` — ${line.reason}` : ""}${line.candidates?.map((candidate) => `\nalso: ${candidate.label} = ${candidate.value.head} (${candidate.value.p})`).join("") ?? ""}`;
+        case "unjudged":
+            return `unjudged  ${line.label} — ${line.reason}; ${line.next}`;
+        case "entry": {
+            const readable = [line.candidate, ...(line.candidates ?? [])]
+                .map((candidate) => candidate.value.head)
+                .filter((head) => typeof head === "string" && head !== "none");
+            const action = readable.length > 1
+                ? "read both"
+                : readable.length === 1
+                    ? `read ${readable[0]}; rephrase goal or widen scope if needed`
+                    : "rephrase goal or widen scope";
+            return `${line.band === "unsure" ? `unsure  entry — ${action}` : `${line.band === "verdict" ? "" : `${line.band}  `}entry: ${line.candidate.value.head} (${line.candidate.value.p.toFixed(2)})`}${line.band === "unsure" ? `\n  ${line.candidate.value.head} ${line.candidate.value.p.toFixed(2)}` : ""}${line.orderDependent && line.orderProbabilities ? ` (order-dependent: ${line.orderProbabilities.map((p) => p.toFixed(2)).join(" / ")})` : ""}${line.candidates?.map((candidate) => `\n  ${candidate.value.head} ${candidate.value.p.toFixed(2)}`).join("") ?? ""}${line.relevant?.length ? `\nrelevant:\n${line.relevant.map((candidate) => `  ${candidate.value.head} ${candidate.value.p.toFixed(2)}`).join("\n")}` : ""}${line.nextRead?.length ? `\nread ${line.nextRead.join(" · ")}` : ""}`;
+        }
+        case "list":
+            return `${line.title}:\n${line.items.map((item) => `  - ${item}`).join("\n")}`;
+        case "command":
+            return `run: cwd: ${line.cwd} · framework: ${line.framework}${line.config ? ` · config: ${line.config}` : ""}${line.project ? ` · project: ${line.project}` : ""} · command: ${[line.executable, ...line.args].map((arg) => (/^[a-zA-Z0-9_./:@+-]+$/.test(arg) ? arg : `'${arg.replaceAll("'", "'\\''")}'`)).join(" ")}`;
+        case "fact":
+            return `[${line.fact}${line.next ? `; ${line.next}` : ""}]`;
+        case "limit-group":
+            return `[${line.cause}: ${line.count} limit${line.count === 1 ? "" : "s"} (${line.priority ? "selected tests / changed units" : "remaining inventory"}) — ${line.examples.join(" · ")}${line.remaining ? ` · +${line.remaining} more (bounded path list)` : ""}; ${line.next}]`;
+        case "collection":
+            return `[${line.title}: ${line.count} sections — ${line.items.join(" · ")}${line.count > line.items.length ? ` · +${line.count - line.items.length} more (bounded section list)` : ""}; ${line.next}]`;
+        case "unchecked":
+            return `unchecked: ${line.items.join(" · ")}`;
+        case "refusal":
+            return line.message;
+        case "yield": {
+            const value = line.value;
+            return `${value.calls} calls · ${value.questions} questions · ${value.costUsd === undefined ? "cost unavailable" : `$${value.costUsd.toFixed(5)}`} · cache ${value.cacheHits}/${value.cacheRequests} · ${(value.elapsedMs / 1000).toFixed(1)} s`;
+        }
+    }
+}
+export function renderEnvelope(envelope) {
+    return envelope.lines.map(renderLine).join("\n");
+}
+function knowledge(value, format = String) {
+    return value.status === "known"
+        ? format(value.value)
+        : `${value.status} (${value.reason})`;
+}
+function scopeLabel(scope) {
+    return scope.kind === "call"
+        ? "call"
+        : scope.kind === "item"
+            ? `items ${scope.itemIds.join(", ")}`
+            : scope.kind === "group"
+                ? `groups ${scope.groupIds.join(", ")}`
+                : `inventory ${scope.inventoryIds.join(", ")}`;
+}
+/** Human projection uses the same typed facts as structured transport, never prose inference. */
+export function renderResultReport(report, options = {}) {
+    const { context: c, accounting: a } = report;
+    const counts = a.requestedResults;
+    const mode = counts.fresh + counts.cache
+        ? `${counts.fresh} fresh / ${counts.cache} cache Jev results`
+        : counts.static
+            ? "static selection; no Jev judgment"
+            : report.items.some((item) => item.selection?.selected)
+                ? "conservative fallback selection; no Jev judgment"
+                : "no admissible judgment";
+    const lines = [
+        `${report.execution} — ${mode}${counts.notJudged ? `; ${counts.notJudged} not judged` : ""}`,
+        `context: authority ${knowledge(c.authority, (v) => `${v.path} (${v.origin})`)} · requested root ${knowledge(c.requestedRoot)} · effective root ${knowledge(c.effectiveRoot, (v) => `${v.path} (${v.origin}); common-dir ${knowledge(v.commonDir)}`)} · base ${knowledge(c.requestedBase)} → ${knowledge(c.resolvedBase)}`,
+    ];
+    for (const inv of c.inventories) {
+        lines.push(`inventory ${inv.id} (${inv.kind}): discovered ${knowledge(inv.discovered)} · considered ${knowledge(inv.considered)} · scopeRestricted ${inv.scopeRestricted} · rules ${inv.rules.join("; ")} · restrictions ${inv.restrictions.join("; ") || "none"}`);
+        for (const criterion of inv.criteria)
+            lines.push(`criterion ${JSON.stringify(criterion.criterion)}: ${criterion.outcome}; matches ${knowledge(criterion.matches)}`);
+    }
+    if (c.command.execution !== "not_requested")
+        lines.push(`command: ${c.command.execution} · cwd ${knowledge(c.command.cwd)} · exit ${knowledge(c.command.exitCode)} · timedOut ${knowledge(c.command.timedOut)}`);
+    for (const item of report.items) {
+        if (item.treatment === "judged") {
+            const j = item.judgment;
+            lines.push(`${j.band === "verdict" ? "" : `${j.band}  `}${j.uncalibrated ? "uncalibrated  " : ""}${item.label} = ${String(j.result)} (${j.measure.kind} ${knowledge(j.measure.value)}) [${item.source}]${j.reason ? ` — ${j.reason}` : ""}`);
+            for (const raw of j.rawValues)
+                lines.push(`  raw ${raw.label} = ${String(raw.value)}; probability ${knowledge(raw.probability)}`);
+            for (const control of j.controls) {
+                lines.push(`  control ${control.id} (${control.kind}, ${control.source}): ${control.outcome}`);
+                for (const raw of control.rawValues)
+                    lines.push(`    raw ${raw.label} = ${String(raw.value)}; probability ${knowledge(raw.probability)}`);
+            }
+        }
+        else
+            lines.push(`${item.treatment === "static" ? "static" : "unjudged"}  ${item.label}${item.treatment === "static" ? ` — ${item.staticReason}` : ""}`);
+        for (const evidence of item.evidence)
+            lines.push(`  evidence ${evidence.target} (${evidence.side}): ${knowledge(evidence.canonicalPath)} · aliases ${evidence.aliases.join(", ") || "none"} · revision ${knowledge(evidence.revision)}`);
+        if (item.selection)
+            lines.push(`  selection: ${item.selection.selected ? "selected" : "not selected"} — ${item.selection.reason}`);
+        if (item.diagnosticIds.length)
+            lines.push(`  diagnostics ${item.diagnosticIds.join(", ")}`);
+        if (item.actionIds.length)
+            lines.push(`  actions ${item.actionIds.join(", ")}`);
+    }
+    // Complete diagnostic lists keep legacy text-only clients self-contained.
+    for (const d of report.diagnostics)
+        lines.push(`${d.material ? "material " : ""}${d.effect} ${d.id} — ${d.cause}: ${d.fact} · target ${knowledge(d.target)} · origin ${d.origin} · scope ${scopeLabel(d.scope)} · members ${knowledge(d.memberCount)}${d.omittedMembers.length ? ` · omitted ${d.omittedMembers.join(", ")}` : ""} · actions ${d.actionIds.join(", ") || "none"}`);
+    for (const action of report.actions)
+        lines.push(`next ${action.id} (${action.code}; ${scopeLabel(action.scope)}; target ${knowledge(action.target)}): ${action.condition} — ${action.instruction}`);
+    if (options.details) {
+        const detailLines = options.details.lines.filter((line) => line.type === "command" || line.type === "list");
+        if (detailLines.length)
+            lines.push("details:", renderEnvelope({ lines: detailLines }));
+    }
+    lines.push(`HTTP attempts ${a.httpAttempts} · questions sent ${a.questionsSent} · requested results total ${knowledge(counts.total)} / fresh ${counts.fresh} / cache ${counts.cache} / not judged ${counts.notJudged} / static ${counts.static} · cache probes ${a.cacheHits}/${a.cacheRequests} · auxiliary controls fresh ${a.auxiliary.controls.fresh} / cache ${a.auxiliary.controls.cache} / not judged ${a.auxiliary.controls.notJudged} / static ${a.auxiliary.controls.static} · passages fresh ${a.auxiliary.passages.fresh} / cache ${a.auxiliary.passages.cache} / not judged ${a.auxiliary.passages.notJudged} · current cost USD ${knowledge(a.costUsd)} · elapsed ${a.elapsedMs} ms`);
+    return lines.join("\n");
+}