@purista/harness 1.0.0 → 1.1.0

package/dist/testing/fakeMemoryAdapter.js

@@ -0,0 +1,110 @@
+import { describe, expect, it } from 'vitest';
+/** Deterministic in-memory adapter for unit tests and adapter contract examples. */
+export class FakeMemoryAdapter {
+    info = {
+        id: 'fake_memory',
+        packageName: '@purista/harness/testing',
+        capabilities: [
+            'memory.kv',
+            'memory.list',
+            'memory.delete',
+            'memory.search',
+            'memory.run',
+            'memory.session',
+            'memory.agent',
+            'memory.user',
+            'memory.tenant',
+            'memory.persistent'
+        ]
+    };
+    capabilities = this.info.capabilities;
+    openedScopes = [];
+    values = new Map();
+    configureHarnessContext() {
+        // Fake adapter does not need inherited services, but implements the hook so contract users can assert it is called.
+    }
+    async open(scope, _ctx) {
+        this.openedScopes.push(scope);
+        const prefix = scopeKey(scope);
+        return {
+            get: async (key, ctx) => {
+                ctx.signal.throwIfAborted();
+                return this.values.get(`${prefix}:${key}`);
+            },
+            set: async (key, value, ctx) => {
+                ctx.signal.throwIfAborted();
+                this.values.set(`${prefix}:${key}`, value);
+            },
+            delete: async (key, ctx) => {
+                ctx.signal.throwIfAborted();
+                this.values.delete(`${prefix}:${key}`);
+            },
+            list: async (ctx) => {
+                ctx.signal.throwIfAborted();
+                const keys = [...this.values.keys()]
+                    .filter((key) => key.startsWith(`${prefix}:`))
+                    .map((key) => key.slice(prefix.length + 1))
+                    .filter((key) => !ctx.opts?.prefix || key.startsWith(ctx.opts.prefix))
+                    .filter((key) => !ctx.opts?.cursor || key > ctx.opts.cursor)
+                    .sort()
+                    .slice(0, ctx.opts?.limit);
+                return keys.map((key) => ({ key }));
+            },
+            search: async (query, ctx) => {
+                ctx.signal.throwIfAborted();
+                return [...this.values.entries()]
+                    .filter(([key]) => key.startsWith(`${prefix}:`))
+                    .map(([key, value]) => ({ key: key.slice(prefix.length + 1), value, score: JSON.stringify(value).includes(query.text) ? 1 : 0 }))
+                    .filter((result) => result.score > 0)
+                    .sort((a, b) => (b.score ?? 0) - (a.score ?? 0) || a.key.localeCompare(b.key))
+                    .slice(0, query.limit);
+            }
+        };
+    }
+}
+/** Shared contract for memory adapters. */
+export function memoryAdapterContract(make) {
+    describe('memoryAdapterContract', () => {
+        it('round-trips scoped JSON values', async () => {
+            const adapter = await make();
+            const ctx = contractContext();
+            const store = await adapter.open({ kind: 'session', sessionId: 's1' }, ctx);
+            await store.set('foo', { a: 1 }, { ...ctx, scope: { kind: 'session', sessionId: 's1' }, operation: 'set' });
+            await expect(store.get('foo', { ...ctx, scope: { kind: 'session', sessionId: 's1' }, operation: 'get' })).resolves.toEqual({ a: 1 });
+        });
+        it('isolates scopes', async () => {
+            const adapter = await make();
+            const ctx = contractContext();
+            const one = await adapter.open({ kind: 'session', sessionId: 's1' }, ctx);
+            const two = await adapter.open({ kind: 'session', sessionId: 's2' }, ctx);
+            await one.set('foo', 'one', { ...ctx, scope: { kind: 'session', sessionId: 's1' }, operation: 'set' });
+            await expect(two.get('foo', { ...ctx, scope: { kind: 'session', sessionId: 's2' }, operation: 'get' })).resolves.toBeUndefined();
+        });
+    });
+}
+function scopeKey(scope) {
+    return [
+        scope.kind,
+        scope.tenantId,
+        scope.userId,
+        scope.sessionId,
+        scope.runId,
+        scope.workflowId,
+        scope.agentId
+    ].filter(Boolean).join(':');
+}
+function contractContext() {
+    const signal = new AbortController().signal;
+    return {
+        logger: { trace() { }, debug() { }, info() { }, warn() { }, error() { }, fatal() { }, child: () => contractContext().logger },
+        telemetry: {
+            span: async (_name, _attrs, fn) => fn({ setAttribute: () => undefined, setAttributes: () => undefined, addEvent: () => undefined, recordException: () => undefined, setStatus: () => undefined, end: () => undefined, spanContext: () => ({ traceId: '', spanId: '', traceFlags: 0 }), isRecording: () => false, updateName: () => undefined }),
+            recordHistogram() { },
+            recordCounter() { },
+            currentTraceparent: () => undefined
+        },
+        metrics: { counter() { }, histogram() { }, duration: async (_name, _attrs, fn) => fn() },
+        contentCaptureMode: 'NO_CONTENT',
+        signal
+    };
+}

package/dist/testing/index.d.ts

@@ -1,6 +1,9 @@
 export { FakeModelProvider } from './fakeModelProvider.js';
+export { FakeMemoryAdapter, memoryAdapterContract } from './fakeMemoryAdapter.js';
 export { adapterCapabilitiesContract, fakeCapabilityAdapter, type FakeCapabilityAdapter } from './capabilities.js';
 export { createInMemoryFeedbackRecorder } from './feedback.js';
+export { evaluateDeterministicScorer } from '../eval/index.js';
+export type { DeterministicScorerDefinition, ScorerResult, ScorerTarget } from '../eval/index.js';
 export { sandboxContract } from './sandboxContract.js';
 export { fakeSnapshotSandbox, sandboxSnapshotContract } from './sandboxSnapshot.js';
 export { stateStoreContract } from './stateStoreContract.js';

package/dist/testing/index.js

@@ -1,7 +1,9 @@
 import { defineHarness } from '../harness/defineHarness.js';
 export { FakeModelProvider } from './fakeModelProvider.js';
+export { FakeMemoryAdapter, memoryAdapterContract } from './fakeMemoryAdapter.js';
 export { adapterCapabilitiesContract, fakeCapabilityAdapter } from './capabilities.js';
 export { createInMemoryFeedbackRecorder } from './feedback.js';
+export { evaluateDeterministicScorer } from '../eval/index.js';
 export { sandboxContract } from './sandboxContract.js';
 export { fakeSnapshotSandbox, sandboxSnapshotContract } from './sandboxSnapshot.js';
 export { stateStoreContract } from './stateStoreContract.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@purista/harness",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Self-hosted enterprise agent harness for typed tools, agents, workflows, state, sandboxing, and telemetry.",
   "type": "module",
   "main": "dist/index.js",
@@ -39,10 +39,12 @@
   "scripts": {
     "clean": "rm -rf dist",
     "build": "npm run clean && tsc -p tsconfig.json",
+    "lint": "npm run typecheck",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test:types": "tsc -p tsconfig.type-tests.json",
     "test": "vitest run",
     "test:unit": "vitest run src",
+    "test:coverage": "vitest run --coverage",
     "test:contracts": "vitest run src/ports test/sandbox.test.ts",
     "test:integration": "vitest run test/harness.test.ts test/tools.test.ts test/skills.test.ts test/telemetry-flow.test.ts",
     "test:failure": "vitest run test/failure"
@@ -54,7 +56,7 @@
   "peerDependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@opentelemetry/api": "^1.9.1",
-    "just-bash": "^2.14.4"
+    "just-bash": "^3.0.1"
   },
   "peerDependenciesMeta": {
     "@modelcontextprotocol/sdk": {
@@ -68,8 +70,11 @@
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@opentelemetry/context-async-hooks": "^2.7.1",
     "@types/node": "^25.6.0",
-    "just-bash": "^2.14.4",
+    "just-bash": "^3.0.1",
     "typescript": "^6.0.3",
     "vitest": "^4.1.5"
+  },
+  "engines": {
+    "node": ">=24.15.0"
   }
 }