jev-recipes 0.2.0 → 0.3.0

package/dist/catalog/index.js

@@ -1,31 +1,15 @@
-import { z } from 'zod';
-import { recipeMetadataSchema } from '../src/schema.js';
-import { recipes } from './recipes.js';
+import { readFileSync } from 'node:fs';
+import { recipeMetadata } from './generated/metadata.js';
 import { recipeFiltersSchema, recipeNameSchema } from './schema.js';
+import { searchRecipes } from './search.js';
 export function listRecipes(filters = {}) {
-    const { query, category } = recipeFiltersSchema.parse(filters);
-    const searchTerms = query?.toLowerCase().trim().split(/\s+/) ?? [];
-    return Object.entries(recipes)
-        .map(([id, recipe]) => ({
-        ...recipeMetadataSchema.parse(recipe.metadata),
-        id: recipeNameSchema.parse(id),
-    }))
-        .filter((recipe) => category === undefined || recipe.category === category)
-        .filter((recipe) => matchesSearch(recipe, searchTerms));
+    return structuredClone(searchRecipes(recipeMetadata, recipeFiltersSchema.parse(filters)));
 }
 export function describeRecipe(name) {
-    const recipe = recipes[recipeNameSchema.parse(name)];
-    return {
-        ...recipeMetadataSchema.parse(recipe.metadata),
-        inputSchema: z.toJSONSchema(recipe.inputSchema, { io: 'input' }),
-        resultSchema: z.toJSONSchema(recipe.resultSchema),
-    };
-}
-function matchesSearch(recipe, terms) {
-    const text = [recipe.id, recipe.title, recipe.description, recipe.category, ...recipe.tags]
-        .join(' ')
-        .toLowerCase();
-    return terms.every((term) => text.includes(term));
+    const id = recipeNameSchema.parse(name);
+    const metadata = recipeMetadata.find((recipe) => recipe.id === id);
+    const schemas = JSON.parse(readFileSync(new URL(`./generated/details/${id}.json`, import.meta.url), 'utf8'));
+    return { ...structuredClone(metadata), ...schemas };
 }
 export { recipeFiltersSchema, recipeNameSchema } from './schema.js';
 export { recipeCategorySchema, recipeMetadataSchema } from '../src/schema.js';

package/dist/catalog/runner.d.ts

@@ -0,0 +1,4 @@
+import type { RecipeOptions } from '../src/schema.js';
+import type { RecipeName } from './schema.js';
+export type RecipeRunner = (input: unknown, options?: RecipeOptions) => Promise<unknown>;
+export declare function loadRecipe(name: RecipeName): Promise<RecipeRunner>;

package/dist/catalog/runner.js

@@ -0,0 +1,5 @@
+import { recipeLoaders } from './generated/loaders.js';
+import { recipeNameSchema } from './schema.js';
+export function loadRecipe(name) {
+    return recipeLoaders[recipeNameSchema.parse(name)]();
+}

package/dist/catalog/schema.d.ts

@@ -1,71 +1,71 @@
 import { z } from 'zod';
 export declare const recipeNameSchema: z.ZodEnum<{
-    route: "route";
-    answerability: "answerability";
+    "action-scope": "action-scope";
+    "answer-consistency": "answer-consistency";
     "answer-coverage": "answer-coverage";
+    "answer-invalidation": "answer-invalidation";
     "answer-relevance": "answer-relevance";
+    answerability: "answerability";
+    "argument-fit": "argument-fit";
+    "attempted-step": "attempted-step";
+    "audience-fit": "audience-fit";
+    "cache-match": "cache-match";
+    "cancellation-check": "cancellation-check";
+    "certainty-match": "certainty-match";
+    "change-meaning": "change-meaning";
     "citation-match": "citation-match";
-    verify: "verify";
     "citation-needed": "citation-needed";
-    "answer-consistency": "answer-consistency";
-    "summary-coverage": "summary-coverage";
-    "certainty-match": "certainty-match";
-    "promise-check": "promise-check";
-    "tone-check": "tone-check";
+    clarify: "clarify";
+    "confirmation-match": "confirmation-match";
+    "context-role": "context-role";
+    "correction-target": "correction-target";
+    "document-role": "document-role";
     "draft-compare": "draft-compare";
-    rerank: "rerank";
-    "retrieval-needed": "retrieval-needed";
-    "freshness-needed": "freshness-needed";
-    "source-applicability": "source-applicability";
     "evidence-conflict": "evidence-conflict";
-    "passage-duplicate": "passage-duplicate";
     "evidence-novelty": "evidence-novelty";
-    "cache-match": "cache-match";
+    "fact-stability": "fact-stability";
+    "failure-kind": "failure-kind";
+    "feedback-kind": "feedback-kind";
+    "field-select": "field-select";
+    "followup-link": "followup-link";
+    "freshness-needed": "freshness-needed";
+    "frustration-signal": "frustration-signal";
+    handoff: "handoff";
+    "incident-match": "incident-match";
+    "instruction-fit": "instruction-fit";
+    "intent-change": "intent-change";
+    "issue-impact": "issue-impact";
+    "memory-relation": "memory-relation";
+    "memory-scope": "memory-scope";
+    "memory-value": "memory-value";
+    "passage-duplicate": "passage-duplicate";
+    "preference-kind": "preference-kind";
+    "promise-check": "promise-check";
     "query-equivalence": "query-equivalence";
-    "context-role": "context-role";
     "query-specificity": "query-specificity";
-    clarify: "clarify";
-    "turn-intent": "turn-intent";
-    "followup-link": "followup-link";
     "reference-resolve": "reference-resolve";
-    "intent-change": "intent-change";
-    "correction-target": "correction-target";
-    "confirmation-match": "confirmation-match";
-    "cancellation-check": "cancellation-check";
-    "topic-shift": "topic-shift";
-    "response-needed": "response-needed";
+    "repeated-attempt": "repeated-attempt";
+    "reply-template-match": "reply-template-match";
+    rerank: "rerank";
     "resolution-check": "resolution-check";
-    handoff: "handoff";
-    "tool-fit": "tool-fit";
-    "argument-fit": "argument-fit";
-    "result-usefulness": "result-usefulness";
+    "response-needed": "response-needed";
     "result-outcome": "result-outcome";
-    "action-scope": "action-scope";
-    "step-progress": "step-progress";
-    "repeated-attempt": "repeated-attempt";
+    "result-usefulness": "result-usefulness";
+    "retrieval-needed": "retrieval-needed";
+    route: "route";
+    "source-applicability": "source-applicability";
     "step-complete": "step-complete";
-    "failure-kind": "failure-kind";
-    "instruction-fit": "instruction-fit";
-    "issue-impact": "issue-impact";
-    "attempted-step": "attempted-step";
-    "workaround-fit": "workaround-fit";
+    "step-progress": "step-progress";
+    "summary-coverage": "summary-coverage";
     "ticket-match": "ticket-match";
-    "incident-match": "incident-match";
+    "tone-check": "tone-check";
+    "tool-fit": "tool-fit";
+    "topic-shift": "topic-shift";
     "troubleshooting-fit": "troubleshooting-fit";
-    "frustration-signal": "frustration-signal";
+    "turn-intent": "turn-intent";
     "urgency-signal": "urgency-signal";
-    "feedback-kind": "feedback-kind";
-    "reply-template-match": "reply-template-match";
-    "memory-value": "memory-value";
-    "memory-scope": "memory-scope";
-    "memory-relation": "memory-relation";
-    "preference-kind": "preference-kind";
-    "fact-stability": "fact-stability";
-    "document-role": "document-role";
-    "audience-fit": "audience-fit";
-    "change-meaning": "change-meaning";
-    "answer-invalidation": "answer-invalidation";
-    "field-select": "field-select";
+    verify: "verify";
+    "workaround-fit": "workaround-fit";
 }>;
 export declare const recipeFiltersSchema: z.ZodObject<{
     query: z.ZodOptional<z.ZodString>;
@@ -78,6 +78,7 @@ export declare const recipeFiltersSchema: z.ZodObject<{
         memory: "memory";
         knowledge: "knowledge";
     }>>;
+    limit: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type RecipeName = z.infer<typeof recipeNameSchema>;
 export type RecipeFilters = z.infer<typeof recipeFiltersSchema>;

package/dist/catalog/schema.js

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import { nonEmptyText, recipeCategorySchema } from '../src/schema.js';
-import { recipes } from './recipes.js';
-const recipeNames = Object.keys(recipes);
+import { recipeNames } from './generated/names.js';
 export const recipeNameSchema = z.enum(recipeNames);
 export const recipeFiltersSchema = z.object({
     query: nonEmptyText.optional(),
     category: recipeCategorySchema.optional(),
+    limit: z.number().int().positive().optional(),
 });

package/dist/catalog/search.d.ts

@@ -0,0 +1,3 @@
+import type { RecipeMetadata } from '../src/schema.js';
+import type { RecipeFilters } from './schema.js';
+export declare function searchRecipes<T extends RecipeMetadata>(recipes: readonly T[], filters: RecipeFilters): T[];

package/dist/catalog/search.js

@@ -0,0 +1,60 @@
+const stopWords = new Set([
+    'a',
+    'an',
+    'the',
+    'i',
+    'this',
+    'is',
+    'my',
+    'to',
+    'of',
+    'for',
+    'in',
+    'it',
+    'do',
+    'does',
+    'how',
+    'should',
+    'with',
+]);
+export function searchRecipes(recipes, filters) {
+    const query = normalize(filters.query ?? '');
+    const words = query.split(' ').filter(Boolean);
+    const significantWords = words.filter((word) => !stopWords.has(word));
+    const terms = significantWords.length ? significantWords : words;
+    return recipes
+        .filter((recipe) => filters.category === undefined || recipe.category === filters.category)
+        .map((recipe) => ({ recipe, score: scoreRecipe(recipe, query, terms) }))
+        .filter(({ score }) => score >= 0)
+        .sort((a, b) => b.score - a.score || a.recipe.id.localeCompare(b.recipe.id, 'en'))
+        .slice(0, filters.limit)
+        .map(({ recipe }) => recipe);
+}
+function scoreRecipe(recipe, query, terms) {
+    if (!query)
+        return 0;
+    const fields = [
+        [normalize(recipe.id), 40],
+        [normalize(recipe.title), 25],
+        [normalize(recipe.tags.join(' ')), 20],
+        [normalize(recipe.useWhen ?? ''), 10],
+        [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 normalize(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^\p{L}\p{N}]+/gu, ' ')
+        .trim();
+}

package/dist/cli/index.js

@@ -2,7 +2,7 @@
 import { readFile } from 'node:fs/promises';
 import { stdin, stdout, stderr } from 'node:process';
 import { z } from 'zod';
-import { recipes } from '../catalog/recipes.js';
+import { loadRecipe } from '../catalog/runner.js';
 import { listRecipes, describeRecipe, recipeCategorySchema } from '../catalog/index.js';
 import { commandArgumentsSchema, demoFixtureSchema } from './schema.js';
 async function main() {
@@ -34,8 +34,8 @@ function parseCommandArguments(args) {
 function printHelp() {
     stdout.write(`jev-recipes
 
-  jev-recipes list [query] [--category <category>]
-                                        Discover recipes (all search terms must match)
+  jev-recipes list [query] [--category <category>] [--limit <count>]
+                                        Find recipes, with the closest matches first
   jev-recipes describe <recipe>         Print metadata, JSON schemas, and example input
   jev-recipes demo <recipe|all>         Run offline fixtures (no model calls)
   jev-recipes example <recipe>          Print example input as JSON
@@ -55,9 +55,11 @@ async function printVersion() {
 }
 function printRecipeList(args) {
     const categoryPosition = args.indexOf('--category');
-    const query = args[0] === '--category' ? undefined : args[0];
+    const limitPosition = args.indexOf('--limit');
+    const query = args[0]?.startsWith('--') ? undefined : args[0];
     const category = categoryPosition === -1 ? undefined : recipeCategorySchema.parse(args[categoryPosition + 1]);
-    printJson(listRecipes({ query, category }));
+    const limit = limitPosition === -1 ? undefined : Number(args[limitPosition + 1]);
+    printJson(listRecipes({ query, category, limit }));
 }
 async function printRecipeDescription(name) {
     const fixture = await readDemoFixture(name);
@@ -76,7 +78,8 @@ async function runOfflineRecipes(name) {
 async function evaluateOfflineRecipe(name) {
     const fixture = await readDemoFixture(name);
     const fixtureClient = { systemOne: async () => fixture.response };
-    const result = await recipes[name].run(fixture.input, { client: fixtureClient });
+    const run = await loadRecipe(name);
+    const result = await run(fixture.input, { client: fixtureClient });
     return {
         mode: 'demo',
         recipe: name,
@@ -85,12 +88,18 @@ async function evaluateOfflineRecipe(name) {
     };
 }
 async function runLiveRecipe(name, source) {
+    if (!process.env.TYPESAFE_API_KEY?.trim()) {
+        throw new Error('Set TYPESAFE_API_KEY in your environment before running a live recipe. Try jev-recipes demo ' +
+            name +
+            ' without a key.');
+    }
     const inputJson = source === '-' ? await readStandardInput() : await readFile(source, 'utf8');
-    const result = await recipes[name].run(JSON.parse(inputJson));
+    const run = await loadRecipe(name);
+    const result = await run(JSON.parse(inputJson));
     printJson({ mode: 'live', result });
 }
 async function readDemoFixture(name) {
-    const fixturePath = new URL(`../../recipes/${name}/demo.json`, import.meta.url);
+    const fixturePath = new URL(`../recipes/${name}/demo.json`, import.meta.url);
     const fixtureJson = await readFile(fixturePath, 'utf8');
     return demoFixtureSchema.parse(JSON.parse(fixtureJson));
 }