kenaz 0.3.18 → 0.3.20

package/core/.specialist/tools/jev-optional-context.test.js

@@ -1,152 +0,0 @@
-'use strict';
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const path = require('node:path');
-const { loadOptionalContext, CATALOG } = require('./jev-optional-context');
-
-function fixture(t) {
-  const root = fs.mkdtempSync(path.resolve('.kenaz/jev-context-test-'));
-  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
-  const catalog = ['a', 'b', 'c'].map(id => ({ id, source: `${id}.txt`, purpose: `Static purpose ${id}` }));
-  for (const item of catalog) fs.writeFileSync(path.join(root, item.source), `LOCAL_BODY_${item.id}`);
-  const effects = { requests: [], reads: [] };
-  const deps = { coreRoot: root, catalog, enabled: () => true,
-    fs: { ...fs, openSync: (file, mode) => { effects.reads.push(path.basename(file)); return fs.openSync(file, mode); } },
-    postRank: async payload => { effects.requests.push(payload); return { status: 'ranked', orderedIds: ['c', 'a', 'b'], scores: [3, 2, 1] }; },
-  };
-  return { root, deps, effects, run: () => loadOptionalContext({ projectPath: root, prompt: 'investigate context' }, deps) };
-}
-
-test('ON ranks static purposes and locally loads only the top two with provenance', async t => {
-  const f = fixture(t), result = await f.run();
-  assert.equal(result.status, 'loaded');
-  assert.deepEqual(result.selectedIds, ['c', 'a']);
-  assert.deepEqual(f.effects.reads, ['c.txt', 'a.txt']);
-  assert.deepEqual(f.effects.requests[0].candidates, f.deps.catalog.map(c => ({ id: c.id, text: c.purpose })));
-  assert.ok(!JSON.stringify(f.effects.requests).includes('LOCAL_BODY'));
-  assert.match(result.context, /reference DATA/);
-  assert.match(result.context, /c.txt/);
-  assert.match(result.context, /LOCAL_BODY_c/);
-  assert.doesNotMatch(result.context, /LOCAL_BODY_b/);
-});
-
-test('OFF, other specialists and huge assembled prompts avoid transport and body reads', async t => {
-  const f = fixture(t);
-  f.deps.enabled = () => false;
-  assert.equal((await f.run()).context, '');
-  f.deps.enabled = () => true;
-  for (const payload of [{ specialist: 'Amelia', prompt: 'hello' }, { prompt: 'x'.repeat(4097) }, { prompt: '' }]) {
-    assert.equal((await loadOptionalContext({ projectPath: f.root, ...payload }, f.deps)).context, '');
-  }
-  assert.deepEqual(f.effects.requests, []);
-  assert.deepEqual(f.effects.reads, []);
-});
-
-test('baseline, timeout, invalid permutations and transport errors preserve empty workflow', async t => {
-  const f = fixture(t);
-  for (const response of [null, { status: 'baseline' }, { status: 'ranked', orderedIds: ['a', 'a', 'b'] }, { status: 'ranked', orderedIds: ['a'] }, { status: 'ranked', orderedIds: ['a', 'b', 'outside'] }]) {
-    f.deps.postRank = async () => response;
-    assert.equal((await f.run()).context, '');
-  }
-  f.deps.postRank = async () => { throw new Error('offline'); };
-  assert.equal((await f.run()).context, '');
-  assert.deepEqual(f.effects.reads, []);
-});
-
-test('toggle OFF after await prevents local body reads', async t => {
-  const f = fixture(t); let on = true;
-  f.deps.enabled = () => on;
-  f.deps.postRank = async () => { on = false; return { status: 'ranked', orderedIds: ['a', 'b', 'c'], scores: [3, 3, 3] }; };
-  assert.equal((await f.run()).reason, 'disabled');
-  assert.deepEqual(f.effects.reads, []);
-});
-
-test('UTF8 budget includes escaped content, envelope and provenance', async t => {
-  const f = fixture(t);
-  for (const id of ['a', 'c']) fs.writeFileSync(path.join(f.root, `${id}.txt`), ('漢字😀\n"').repeat(1000));
-  const result = await f.run();
-  assert.equal(result.status, 'loaded');
-  assert.equal(result.bytes, Buffer.byteLength(result.context));
-  assert.ok(result.bytes <= 4096);
-  assert.doesNotMatch(result.context, /\uFFFD/);
-  const refs = JSON.parse(result.context.slice(result.context.indexOf('\n') + 1)).references;
-  assert.ok(refs.every(ref => ref.truncated));
-});
-
-test('missing and oversized candidates are omitted without content reads', async t => {
-  const f = fixture(t);
-  fs.unlinkSync(path.join(f.root, 'b.txt'));
-  fs.writeFileSync(path.join(f.root, 'c.txt'), 'x'.repeat(65537));
-  f.deps.postRank = async payload => {
-    assert.deepEqual(payload.candidates.map(c => c.id), ['a']);
-    return { status: 'ranked', orderedIds: ['a'], scores: [3] };
-  };
-  assert.deepEqual((await f.run()).selectedIds, ['a']);
-  assert.deepEqual(f.effects.reads, ['a.txt']);
-});
-
-test('symlinks, escapes and credential material never become loaded data', async t => {
-  const f = fixture(t);
-  // Deterministic symlink metadata fixture avoids Windows privilege requirements.
-  f.deps.fs.lstatSync = file => file.endsWith('c.txt') ? { isSymbolicLink: () => true } : fs.lstatSync(file);
-  f.deps.catalog.push({ id: 'escape', source: '../outside.txt', purpose: 'outside' });
-  f.deps.postRank = async payload => {
-    assert.deepEqual(payload.candidates.map(c => c.id), ['a', 'b']);
-    return { status: 'ranked', orderedIds: ['a', 'b'], scores: [3, 3] };
-  };
-  fs.writeFileSync(path.join(f.root, 'a.txt'), 'api_key = "abcdefghijklmnop1234567890"');
-  const result = await f.run();
-  assert.equal(result.reason, 'credential_material');
-  assert.equal(result.context, '');
-});
-
-test('selected source disappearing during ranking fails without fallback content', async t => {
-  const f = fixture(t);
-  f.deps.postRank = async () => { fs.unlinkSync(path.join(f.root, 'a.txt')); return { status: 'ranked', orderedIds: ['a', 'b', 'c'], scores: [3, 3, 3] }; };
-  assert.equal((await f.run()).context, '');
-});
-
-test('production catalog contains only six supplemental paths, no mandatory policy', () => {
-  assert.equal(CATALOG.length, 6);
-  for (const item of CATALOG) assert.doesNotMatch(item.source, /kernel|elixir|capability|phase_/);
-});
-
-test('TypeSafe credential format is rejected and only known baseline reasons are returned', async t => {
-  const f = fixture(t);
-  fs.writeFileSync(path.join(f.root, 'c.txt'), 'apikey_SYNTHETIC_NOT_A_REAL_KEY_1234567890');
-  assert.equal((await f.run()).reason, 'credential_material');
-  for (const reason of ['missing_key', 'timeout', 'http_error']) {
-    f.deps.postRank = async () => ({ status: 'baseline', reason });
-    assert.equal((await f.run()).reason, reason);
-  }
-  f.deps.postRank = async () => ({ status: 'baseline', reason: 'private provider failure text' });
-  assert.equal((await f.run()).reason, 'rank_unavailable');
-});
-
-test('relevance floor: nothing scored at least "Useful evidence" loads nothing and reads no bodies', async t => {
-  const f = fixture(t);
-  f.deps.postRank = async () => ({ status: 'ranked', orderedIds: ['c', 'a', 'b'], scores: [1, 1, 0] });
-  const result = await f.run();
-  assert.equal(result.status, 'baseline');
-  assert.equal(result.reason, 'below_threshold');
-  assert.deepEqual(f.effects.reads, []);
-});
-
-test('relevance floor: only candidates at or above 2 load, even if fewer than two', async t => {
-  const f = fixture(t);
-  f.deps.postRank = async () => ({ status: 'ranked', orderedIds: ['c', 'a', 'b'], scores: [2, 1.9, 0] });
-  const result = await f.run();
-  assert.deepEqual(result.selectedIds, ['c']);
-  assert.deepEqual(f.effects.reads, ['c.txt']);
-});
-
-test('a ranked response without aligned scores loads nothing', async t => {
-  for (const bad of [undefined, [3, 2], [3, 'x', 1], [3, NaN, 1]]) {
-    const f = fixture(t);
-    f.deps.postRank = async () => ({ status: 'ranked', orderedIds: ['c', 'a', 'b'], scores: bad });
-    const result = await f.run();
-    assert.equal(result.reason, 'no_scores');
-    assert.deepEqual(f.effects.reads, []);
-  }
-});