jev-recipes 0.9.11 → 0.9.13

package/dist/catalog/search.js

@@ -17,6 +17,12 @@ const stopWords = new Set([
     'should',
     'with',
 ]);
+const EXACT_ID_BONUS = 10_000;
+const FULL_COVERAGE_BONUS = 1_000;
+const PHRASE_BONUS = 50;
+const EXACT_MATCH = 1;
+const SHARED_STEM_MINIMUM_LENGTH = 4;
+const SHARED_STEM_MINIMUM_RATIO = 0.6;
 export function searchRecipes(recipes, filters) {
     const query = normalize(filters.query ?? '');
     const words = query.split(' ').filter(Boolean);
@@ -33,7 +39,19 @@ export function searchRecipes(recipes, filters) {
 function scoreRecipe(recipe, query, terms) {
     if (!query)
         return 0;
-    const fields = [
+    const fields = weightedFields(recipe);
+    const matches = terms.map((term) => bestMatch(fields, term));
+    if (matches.every((match) => match.quality === 0))
+        return -1;
+    const coverage = matches.reduce((total, match) => total + match.quality, 0) / terms.length;
+    const relevance = matches.reduce((total, match) => total + match.weight, 0);
+    return ((normalize(recipe.id) === query ? EXACT_ID_BONUS : 0) +
+        (matchesPhrase(recipe, terms) ? PHRASE_BONUS : 0) +
+        coverage * FULL_COVERAGE_BONUS +
+        relevance);
+}
+function weightedFields(recipe) {
+    return [
         [normalize(recipe.id), 40],
         [normalize(recipe.title), 25],
         [normalize(recipe.tags.join(' ')), 20],
@@ -41,16 +59,32 @@ function scoreRecipe(recipe, query, terms) {
         [normalize(recipe.description), 5],
         [normalize(recipe.category), 1],
     ];
-    let score = normalize(recipe.id) === query ? 1000 : 0;
-    if (terms.length > 1 && normalize(recipe.useWhen ?? '').includes(terms.join(' ')))
-        score += 50;
-    for (const term of terms) {
-        const matches = fields.filter(([text]) => text.includes(term));
-        if (!matches.length)
-            return -1;
-        score += Math.max(...matches.map(([, weight]) => weight));
-    }
-    return score;
+}
+function bestMatch(fields, term) {
+    return fields.reduce((best, [text, fieldWeight]) => {
+        const quality = fieldMatch(text, term);
+        return {
+            quality: Math.max(best.quality, quality),
+            weight: Math.max(best.weight, fieldWeight * quality),
+        };
+    }, { quality: 0, weight: 0 });
+}
+function matchesPhrase(recipe, terms) {
+    return terms.length > 1 && normalize(recipe.useWhen ?? '').includes(terms.join(' '));
+}
+function fieldMatch(text, term) {
+    if (text.includes(term))
+        return EXACT_MATCH;
+    return text.split(' ').reduce((best, word) => Math.max(best, stemSimilarity(word, term)), 0);
+}
+function stemSimilarity(first, second) {
+    const longerLength = Math.max(first.length, second.length);
+    let sharedLength = 0;
+    while (sharedLength < longerLength && first[sharedLength] === second[sharedLength])
+        sharedLength++;
+    const sharesStem = sharedLength >= SHARED_STEM_MINIMUM_LENGTH &&
+        sharedLength >= Math.ceil(longerLength * SHARED_STEM_MINIMUM_RATIO);
+    return sharesStem ? sharedLength / longerLength : 0;
 }
 function normalize(text) {
     return text

package/dist/evaluation/archive.d.ts

@@ -25,8 +25,8 @@ declare const archiveSchema: z.ZodObject<{
     inputFingerprint: z.ZodString;
     answerKeyFingerprint: z.ZodString;
     split: z.ZodEnum<{
-        "held-out": "held-out";
         development: "development";
+        "held-out": "held-out";
     }>;
     requestedModel: z.ZodString;
     policy: z.ZodObject<{
@@ -54,8 +54,8 @@ declare const archiveSchema: z.ZodObject<{
         rationale: z.ZodString;
         family: z.ZodOptional<z.ZodString>;
         split: z.ZodDefault<z.ZodEnum<{
-            "held-out": "held-out";
             development: "development";
+            "held-out": "held-out";
         }>>;
         provenance: z.ZodDefault<z.ZodObject<{
             method: z.ZodEnum<{
@@ -113,7 +113,7 @@ export declare function freezePolicy(run: EvaluationRun): EvaluationPolicy;
 export declare function compare(baseline: EvaluationRun, candidate: EvaluationRun): {
     recipe: string;
     cases: number;
-    split: "held-out" | "development";
+    split: "development" | "held-out";
     baseline: {
         runId: string;
         packageVersion: string;

package/dist/evaluation/comparison.d.ts

@@ -5,5 +5,6 @@ export declare function comparableDecision(value: unknown, recipe: string): unkn
 export declare function matchesExpected(actual: unknown, expected: unknown, recipe: string): boolean;
 export declare function isReady(result: unknown, recipe: string): boolean;
 export declare function isMetadataPath(schema: Schema, segments: string[]): boolean;
+export declare function gatedTwinFor(schema: Schema, segments: string[]): string | undefined;
 export declare function schemaAtPath(schema: Schema, segments: string[]): Schema | undefined;
 export {};

package/dist/evaluation/comparison.js

@@ -76,6 +76,19 @@ export function isMetadataPath(schema, segments) {
     const child = schemaAtPath(schema, [first]);
     return child !== undefined && isMetadataPath(child, rest);
 }
+export function gatedTwinFor(schema, segments) {
+    const name = segments.at(-1);
+    if (name === undefined || !name.length)
+        return undefined;
+    const twin = `suggested${name[0].toUpperCase()}${name.slice(1)}`;
+    const parent = schemaAtPath(schema, segments.slice(0, -1));
+    return parent !== undefined && hasProperty(parent, twin) ? twin : undefined;
+}
+function hasProperty(schema, name) {
+    if (Array.isArray(schema.anyOf))
+        return schema.anyOf.some((branch) => isRecord(branch) && hasProperty(branch, name));
+    return isRecord(schema.properties) && Object.hasOwn(schema.properties, name);
+}
 export function schemaAtPath(schema, segments) {
     if (!segments.length)
         return schema;

package/dist/evaluation/dataset.js

@@ -3,7 +3,7 @@ import { readFile } from 'node:fs/promises';
 import { z } from 'zod';
 import { recipeNameSchema } from '../catalog/schema.js';
 import { isRecord } from './decisions.js';
-import { comparableDecision, isMetadataPath, schemaAtPath, resultSchemaFor } from './comparison.js';
+import { comparableDecision, gatedTwinFor, isMetadataPath, schemaAtPath, resultSchemaFor, } from './comparison.js';
 import { evaluationCaseSchema } from './schema.js';
 export async function loadEvaluationRecipe(name) {
     const id = recipeNameSchema.parse(name);
@@ -45,9 +45,13 @@ export function validateCases(recipe, values) {
         }
         recipe.inputSchema.parse(entry.input);
         for (const [path, expected] of Object.entries(entry.expected)) {
-            if (isMetadataPath(resultSchema, path.split('.')))
+            const segments = path.split('.');
+            if (isMetadataPath(resultSchema, segments))
                 throw new Error(`${entry.id}: expected must name an ungated decision, not ${path}.`);
-            const field = schemaAtPath(resultSchema, path.split('.'));
+            const twin = gatedTwinFor(resultSchema, segments);
+            if (twin)
+                throw new Error(`${entry.id}: ${path} is gated by the review policy; label ${twin} instead.`);
+            const field = schemaAtPath(resultSchema, segments);
             if (!field)
                 throw new Error(`${entry.id}: unknown result field ${path}.`);
             if (!acceptsValue(field, expected))

package/dist/evaluation/engine.js

@@ -81,7 +81,7 @@ async function evaluateCase(recipe, goldenCase, client, options) {
 function recordResponses(client, exchanges) {
     return {
         async systemOne(request, options) {
-            const exchange = { request: structuredClone(request), durationMs: 0 };
+            const exchange = { request: asArchivedRequest(request), durationMs: 0 };
             exchanges.push(exchange);
             const started = performance.now();
             try {
@@ -106,7 +106,8 @@ export function replayResponses(exchanges) {
     return {
         client: {
             async systemOne(request) {
-                const index = remaining.findIndex((exchange) => isDeepStrictEqual(exchange.request, request));
+                const archived = asArchivedRequest(request);
+                const index = remaining.findIndex((exchange) => isDeepStrictEqual(exchange.request, archived));
                 if (index === -1)
                     throw new ReplayMismatch('Replay requested an unrecorded model response. The prompt or model has changed.');
                 const [exchange] = remaining.splice(index, 1);
@@ -121,6 +122,9 @@ export function replayResponses(exchanges) {
         },
     };
 }
+function asArchivedRequest(request) {
+    return JSON.parse(JSON.stringify(request));
+}
 function safeError(error) {
     let message = error instanceof Error ? error.message : String(error);
     for (const [name, value] of Object.entries(process.env)) {

package/dist/evaluation/schema.d.ts

@@ -15,8 +15,8 @@ export declare const evaluationCaseSchema: z.ZodObject<{
     rationale: z.ZodString;
     family: z.ZodOptional<z.ZodString>;
     split: z.ZodDefault<z.ZodEnum<{
-        "held-out": "held-out";
         development: "development";
+        "held-out": "held-out";
     }>>;
     provenance: z.ZodDefault<z.ZodObject<{
         method: z.ZodEnum<{
@@ -54,8 +54,8 @@ export declare const evaluationOptionsSchema: z.ZodObject<{
     maxRequests: z.ZodDefault<z.ZodNumber>;
     model: z.ZodOptional<z.ZodString>;
     split: z.ZodDefault<z.ZodEnum<{
-        "held-out": "held-out";
         development: "development";
+        "held-out": "held-out";
     }>>;
     policy: z.ZodDefault<z.ZodObject<{
         minConfidence: z.ZodOptional<z.ZodNumber>;

package/dist/recipes/game-action/index.js

@@ -1,12 +1,12 @@
 import { choice } from '@typesafe-ai/sdk';
 import { evaluateWithJev } from '../../src/client.js';
 import { parseChoiceAnswer } from '../../src/answers.js';
-import { parseDecisionState } from '../../src/decisions.js';
+import { asDecisionInstruction, parseDecisionState } from '../../src/decisions.js';
 import { gameActionInputSchema, gameActionResultSchema } from './schema.js';
-const instructions = [
+const instructions = asDecisionInstruction([
     'Which available action should this player take next, given the supplied game state, player state, rules, and objective?',
     ...Object.entries(gameActionInputSchema.shape).map(([name, schema]) => `${name}: ${schema.description}`),
-].join('\n');
+].join('\n'));
 export async function gameAction(input, options = {}) {
     const { legalActions, ...state } = gameActionInputSchema.parse(input);
     if (legalActions.length === 0)

package/dist/src/create-client.d.ts

@@ -0,0 +1 @@
+export { createClient } from './client.js';

package/dist/src/create-client.js

@@ -0,0 +1 @@
+export { createClient } from './client.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jev-recipes",
-  "version": "0.9.11",
+  "version": "0.9.13",
   "description": "248 small Jev decisions for JavaScript and TypeScript: route, rerank, gate, grade, compare, and label text for agents, RAG, support, code review, and music. Each returns a typed result with explicit uncertainty. Plug into Vercel AI SDK or LangChain agents, import one recipe, or run the CLI with JSON from any language.",
   "type": "module",
   "license": "MIT",
@@ -19,6 +19,10 @@
       "types": "./dist/src/index.d.ts",
       "import": "./dist/src/index.js"
     },
+    "./client": {
+      "types": "./dist/src/create-client.d.ts",
+      "import": "./dist/src/create-client.js"
+    },
     "./catalog": {
       "types": "./dist/catalog/index.d.ts",
       "import": "./dist/catalog/index.js"