dsh-memsys 0.2.0 → 0.2.1

package/test/p6-inject-round.test.mjs

@@ -0,0 +1,76 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { EventEmitter } from 'node:events';
+
+import { createRoundInjector } from '../src/runtime/inject-round.mjs';
+import { compileRound } from '../src/context/compile.mjs';
+import { conservativeTokens } from '../src/context/budget.mjs';
+import { ingestInput } from '../src/write/observe.mjs';
+import { promoteCandidate, recordCandidates } from '../src/write/candidate.mjs';
+import { createTestContext, mutableClock } from './helpers/fixtures.mjs';
+import { fakeRuntime } from './helpers/runtime.mjs';
+
+function seed(ctx, index) {
+  const runtime = fakeRuntime({ role: 'daily', identity: 'inj', callId: 'inj-' + index, messageSeq: 28000 + index });
+  const observation = ingestInput(runtime, { text: '注入目录记忆-' + index, messageSeq: 28000 + index }, { main: ctx.main, control: ctx.control, clock: ctx.clock });
+  const created = recordCandidates(runtime, {
+    items: [{
+      observationId: observation.observation.id,
+      text: '注入目录记忆-' + index,
+      why: 'w', type: 'fact', scene: 'work', scope: 'work-only',
+      evidenceRefs: [{ observationId: observation.observation.id, sourceSpan: 'bytes:0:5' }],
+    }],
+  }, { main: ctx.main, control: ctx.control, clock: ctx.clock });
+  promoteCandidate(runtime, created.items[0].id, null, { main: ctx.main, control: ctx.control, clock: ctx.clock });
+}
+
+test('P6/inject-round: turn/start refreshes an empty directory into compiled memory ids', (t) => {
+  const ctx = createTestContext({ clock: mutableClock().clock });
+  t.after(() => ctx.cleanup());
+  seed(ctx, 1);
+  const bus = new EventEmitter();
+  const injector = createRoundInjector({
+    ctx: bus,
+    handles: ctx.handles,
+    modules: { context: true },
+    compileRound,
+    tokenizer: conservativeTokens,
+    H: 1000,
+    clock: ctx.clock,
+  });
+  t.after(() => injector.dispose());
+  assert.equal(injector.current().text, '');
+  bus.emit('session/event', { type: 'turn/start', session: { header: { id: 'session-inj' } }, id: 'turn-1' });
+  const current = injector.current();
+  assert.ok(current.text.length > 0, JSON.stringify(current));
+  assert.ok(current.manifest.eligible_ids.length > 0, JSON.stringify(current.manifest));
+  assert.equal(current.delivery, 'unknown');
+});
+
+test('P6/inject-round: missing tokenizer/H falls back to tools-only and never pretends delivery', () => {
+  const ctx = createTestContext({ clock: mutableClock().clock });
+  try {
+    const injector = createRoundInjector({ ctx: { on() {} }, handles: ctx.handles, modules: {}, compileRound, tokenizer: null, H: null, clock: ctx.clock });
+    injector.refresh({ session: { header: { id: 's' } }, id: 't' });
+    assert.equal(injector.current().delivery_level, 'unavailable');
+    assert.equal(injector.current().delivery, 'unknown');
+    assert.match(injector.current().text, /tools-only/);
+  } finally {
+    ctx.cleanup();
+  }
+});
+
+test('P6/inject-round: context=false yields empty text and does not subscribe', () => {
+  const ctx = createTestContext({ clock: mutableClock().clock });
+  try {
+    let subscribed = false;
+    const bus = { on() { subscribed = true; } };
+    const injector = createRoundInjector({ ctx: bus, handles: ctx.handles, modules: { context: false }, compileRound, tokenizer: conservativeTokens, H: 1000, clock: ctx.clock });
+    injector.refresh({ id: 't' });
+    assert.equal(injector.current().text, '');
+    assert.equal(injector.current().delivery_level, 'disabled');
+    assert.equal(subscribed, false);
+  } finally {
+    ctx.cleanup();
+  }
+});

package/test/p6-modules.test.mjs

@@ -0,0 +1,77 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { moduleEnabled, resolveModules } from '../src/runtime/modules.mjs';
+import { toolDefinitions } from '../src/runtime/tools.mjs';
+import { compileRound } from '../src/context/compile.mjs';
+import { conservativeTokens } from '../src/context/budget.mjs';
+import {
+  insertCandidate, insertMemory, insertObservation, insertPointer, insertTimeline,
+} from '../src/storage/repositories.mjs';
+import { createTestContext, makeCandidate, makeMemory, makeObservation, mutableClock } from './helpers/fixtures.mjs';
+
+let seq = 0;
+function pendingMemory(ctx) {
+  seq += 1;
+  const text = '待确认惦记';
+  const observation = makeObservation(ctx, { messageSeq: 27000 + seq, text });
+  insertObservation(ctx.main, observation);
+  const candidate = makeCandidate(ctx, observation, { businessKey: `mod-${seq}`, text, why: '期限', type: 'promise', scene: 'work', scope: 'work-only' });
+  insertCandidate(ctx.main, candidate);
+  const memory = makeMemory(ctx, candidate);
+  Object.assign(memory, { due_state: 'pending-due', scene: 'work', scope: 'work-only' });
+  insertMemory(ctx.main, memory);
+  insertTimeline(ctx.main, { memory_id: memory.id, start_at: null, end_at: null, prec_start: 'unknown', prec_end: 'unknown', time_state: 'point', revision: 1 });
+  insertPointer(ctx.main, { memory_id: memory.id, status: 'unknown', location: null, search_hint: null, lossy: 0, revision: 1 });
+  ctx.main
+    .prepare("INSERT INTO due_queue (memory_id, due_state, enqueued_seq, enqueued_at, opened_at, deadline_at, revision, reason) VALUES (?, 'pending-due', 1, ?, NULL, NULL, 0, 'promote')")
+    .run(memory.id, ctx.clock.at().at);
+  return memory;
+}
+
+test('P6/modules: defaults enable everything and register all 10 tools', () => {
+  const modules = resolveModules({});
+  assert.deepEqual(modules, {
+    context: true, read: true, write: true, dream: true, projects: true, due: true, feed: true,
+  });
+  assert.equal(toolDefinitions({}, modules).length, 10);
+});
+
+test('P6/modules: read=false removes read tools but keeps write/dream/feed', () => {
+  const modules = resolveModules({ modules: { read: false } });
+  const names = toolDefinitions({}, modules).map((tool) => tool.name);
+  for (const name of ['memsys_get', 'memsys_search', 'memsys_review_get', 'memsys_context_get', 'memsys_project_get', 'memsys_self_get']) {
+    assert.ok(!names.includes(name), name);
+  }
+  assert.ok(names.includes('memsys_record'));
+  assert.ok(names.includes('memsys_dream_record'));
+  assert.ok(names.includes('memsys_feed'));
+});
+
+test('P6/modules: context=false disables the injection section', () => {
+  const modules = resolveModules({ modules: { context: false } });
+  assert.equal(moduleEnabled(modules, 'context'), false);
+  assert.equal(moduleEnabled(modules, 'read'), true);
+});
+
+test('P6/modules: due=false removes review:* typed items from compile output', (t) => {
+  const ctx = createTestContext({ clock: mutableClock().clock });
+  t.after(() => ctx.cleanup());
+  const memory = pendingMemory(ctx);
+  const base = { main: ctx.main, control: ctx.control, clock: ctx.clock, sessionId: 's-mod', roundId: 'r-mod', mode: 'work', tokenizer: conservativeTokens, H: 200000 };
+  const enabled = compileRound(base);
+  assert.ok(enabled.eligible_ids.includes('review:due:' + memory.id), JSON.stringify(enabled.eligible_ids));
+  const disabled = compileRound({ ...base, roundId: 'r-mod2', modules: { due: false } });
+  assert.ok(!disabled.eligible_ids.some((id) => id.startsWith('review:')), JSON.stringify(disabled.eligible_ids));
+});
+
+test('P6/modules: legacy auto_inject maps to context without disabling other modules', () => {
+  const modules = resolveModules({ auto_inject: true });
+  assert.equal(modules.context, true);
+  assert.equal(modules.read, true);
+  assert.equal(modules.write, true);
+  assert.equal(modules.dream, true);
+  assert.equal(modules.projects, true);
+  assert.equal(modules.due, true);
+  assert.equal(modules.feed, true);
+});