@specverse/engines 6.60.1 → 6.63.0

package/libs/instance-factories/services/templates/prisma/__tests__/step-conventions-create.test.ts

@@ -0,0 +1,184 @@
+/**
+ * Step-conventions — `create` pattern reserved-word regression.
+ *
+ * Surfaced 2026-05-14 by the 9-cell comparison matrix: sonnet's
+ * idle-meta realize γ-stubbed `PlayersController.post0` with the
+ * precise diagnostic "pre-baked step 7 uses reserved keyword 'new' as
+ * a variable identifier — cannot emit coherently". The pre-baked
+ * snippet was:
+ *
+ *   // Step 7: Create new
+ *   const new = await prisma.new.create({ data: data });
+ *
+ * Root cause: prisma's `create` convention pattern was
+ * `/^create\s+(\w+).../i` — for the step "Create new Player with level 1",
+ * m[1] captured the adjective "new" rather than the noun "Player".
+ * Then toVar("new") = "new" (a JS reserved word) became both the
+ * variable name AND the prisma model name in the generated snippet,
+ * neither of which is legal/correct.
+ *
+ * mongo and pg conventions already had `(?:new\s+)?` in their create
+ * patterns — this was a parity gap. Fix: add the same optional group
+ * to prisma's create pattern. After the fix, m[1] = "Player" → snippet
+ * uses `prisma.player.create`.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { STEP_CONVENTIONS } from '../step-conventions.js';
+import type { StepContext } from '../step-conventions.js';
+
+function findCreateConvention() {
+  const c = STEP_CONVENTIONS.find((x) => x.name === 'create');
+  expect(c).toBeDefined();
+  return c!;
+}
+
+function makeCtx(overrides: Partial<StepContext> = {}): StepContext {
+  return {
+    modelName: 'Player',
+    serviceName: 'PlayersController',
+    operationName: 'post0',
+    stepNum: 7,
+    parameterNames: [],
+    declaredVars: new Set<string>(),
+    ...overrides,
+  } as any;
+}
+
+describe('prisma step-convention `create` — adjective-skip + entity-name correctness', () => {
+  it('extracts the entity noun, not the adjective, from "Create new Player with …"', () => {
+    const convention = findCreateConvention();
+    const m = 'Create new Player with level 1, experience 0'.match(convention.pattern)!;
+    expect(m[1]).toBe('Player');
+  });
+
+  it('emits a snippet referencing `prisma.player` (not `prisma.new`) for the adjective case', () => {
+    const convention = findCreateConvention();
+    const m = 'Create new Player with level 1, experience 0'.match(convention.pattern)!;
+    const call = convention.generateCall(m, makeCtx())!;
+    expect(call).toContain('prisma.player.create');
+    expect(call).not.toContain('prisma.new');
+    expect(call).not.toContain('const new ');
+  });
+
+  it('still works for the no-adjective case "Create Player with …" (no regression)', () => {
+    const convention = findCreateConvention();
+    const m = 'Create Player with level 1'.match(convention.pattern)!;
+    expect(m[1]).toBe('Player');
+    const call = convention.generateCall(m, makeCtx())!;
+    expect(call).toContain('prisma.player.create');
+  });
+
+  it('uses parameter names for the data shape when provided', () => {
+    const convention = findCreateConvention();
+    const m = 'Create new Player with level 1'.match(convention.pattern)!;
+    const call = convention.generateCall(m, makeCtx({ parameterNames: ['userId', 'gameId'] }))!;
+    expect(call).toContain('{ userId, gameId }');
+  });
+
+  it('emits a syntactically valid `const <var> = await prisma.<var>.create(...)` shape', () => {
+    const convention = findCreateConvention();
+    const m = 'Create new Player with level 1'.match(convention.pattern)!;
+    const call = convention.generateCall(m, makeCtx())!;
+    // const <var> = await prisma.<var>.create(...);
+    // Variable name must NOT be a JS reserved word; both the variable
+    // and the prisma model reference should be the lowercased entity.
+    expect(call).toMatch(/const\s+player\s+=\s+await\s+prisma\.player\.create/);
+  });
+
+  // Wider adjective list (engines 6.60.4) — kept in sync with
+  // NL_LEADING_ADJECTIVES in _shared/step-matching.ts.
+  it.each([
+    ['existing', 'Create existing Player with level 1'],
+    ['current',  'Create current Player'],
+    ['the',      'Create the Player with level 1'],
+    ['a',        'Create a Player with level 1'],
+    ['an',       'Create an Order with total 100'],
+  ])('skips the leading adjective %s (no regression for any in the list)', (_adj, step) => {
+    const convention = findCreateConvention();
+    const m = step.match(convention.pattern)!;
+    // m[1] is the noun (Player/Order), never the adjective.
+    expect(['Player', 'Order']).toContain(m[1]);
+    const call = convention.generateCall(m, makeCtx())!;
+    expect(call).not.toMatch(/const\s+(existing|current|the|a|an)\s+=/);
+    expect(call).not.toMatch(/prisma\.(existing|current|the|a|an)\./);
+  });
+});
+
+describe('prisma step-convention `create` — reserved-word safety net', () => {
+  // The pattern's leading-adjective skip catches the common cases. The
+  // safety net catches anything that still leaks a JS reserved word as
+  // the entity name (an adjective not in the skip list, or a mis-parse).
+  // generateCall returns '' → the matcher falls through to the AI
+  // [WRITE] fallback instead of emitting `const class = await prisma.class...`.
+  it.each([
+    ['class',    'Create class Foo'],
+    ['function', 'Create function Bar'],
+    ['delete',   'Create delete Marker'],
+    ['return',   'Create return Receipt'],
+  ])('returns empty string when m[1] would be reserved word "%s"', (reserved, step) => {
+    const convention = findCreateConvention();
+    const m = step.match(convention.pattern);
+    // The pattern still matches structurally; the generateCall guard refuses.
+    if (m) {
+      expect(m[1]!.toLowerCase()).toBe(reserved);
+      const call = convention.generateCall(m, makeCtx());
+      expect(call).toBe('');
+    }
+  });
+
+  it('matches but refuses "Create new class" (post-adjective-skip the captured noun is reserved)', () => {
+    const convention = findCreateConvention();
+    const m = 'Create new class'.match(convention.pattern)!;
+    expect(m[1]).toBe('class');
+    expect(convention.generateCall(m, makeCtx())).toBe('');
+  });
+});
+
+describe('prisma step-conventions — extracted-input reserved-word safety (transition + call-service)', () => {
+  // 2026-05-15 audit of all toVar(extracted) sites. Same shape as the
+  // create-convention safety net above: when the captured noun lowercases
+  // to a TS reserved word, generateCall returns '' so the matcher falls
+  // through to the AI [WRITE] fallback instead of emitting illegal TS.
+
+  function findConvention(name: string) {
+    const c = STEP_CONVENTIONS.find((x) => x.name === name);
+    expect(c).toBeDefined();
+    return c!;
+  }
+
+  it.each([
+    ['delete',  'transition delete to active'],
+    ['return',  'transition return to closed'],
+    ['class',   'transition class to graduated'],
+  ])('transition: refuses reserved-word model "%s"', (_reserved, step) => {
+    const convention = findConvention('transition');
+    const m = step.match(convention.pattern)!;
+    expect(convention.generateCall(m, makeCtx())).toBe('');
+  });
+
+  it('transition: still works for a real model name (no regression)', () => {
+    const convention = findConvention('transition');
+    const m = 'transition Player to active'.match(convention.pattern)!;
+    const ctx = makeCtx({ declaredVars: new Set(['player']) });
+    const call = convention.generateCall(m, ctx)!;
+    expect(call).toContain('prisma.player.update');
+    expect(call).toContain("'active'");
+  });
+
+  it.each([
+    ['delete',  'call delete.purge'],
+    ['return',  'call return.process'],
+  ])('call-service: refuses reserved-word service name "%s"', (_reserved, step) => {
+    const convention = findConvention('call-service');
+    const m = step.match(convention.pattern)!;
+    expect(convention.generateCall(m, makeCtx())).toBe('');
+  });
+
+  it('call-service: still works for a real service name (no regression)', () => {
+    const convention = findConvention('call-service');
+    const m = 'call notificationService.send'.match(convention.pattern)!;
+    const call = convention.generateCall(m, makeCtx())!;
+    expect(call).toContain('notificationService.send');
+  });
+});

package/libs/instance-factories/services/templates/prisma/ai-behaviors-generator.ts

@@ -18,6 +18,7 @@
  */
 
 import type { TemplateContext } from '@specverse/types';
+import { safeFunctionName } from '@specverse/types';
 import { matchStep, type StepContext } from './step-conventions.js';
 import { validateImportWhitelist } from '@specverse/engines/ai';
 import { createHash } from 'crypto';
@@ -352,6 +353,15 @@ export async function generateAiBehaviorsFile(opts: {
   let cacheHits = 0;
   let cacheMisses = 0;
   for (const { functionName, step, operationName, parameterNames, inputs, returns, modelName } of unmatchedFunctions) {
+    // Reserved-word safety for the function declaration. `functionName`
+    // came from `toMethod(step)` in step-matching; a step text like
+    // "Delete" camelCases to `delete` — a JS keyword that's illegal as
+    // a function-declaration identifier. Suffix-rename the decl and
+    // append a re-export so callers (`aiBehaviors.delete(...)`) still
+    // resolve via the re-export's binding. Same shape as the γ-stub
+    // renderers in per-owner-runner + per-action-recovery.
+    const { name: safeName, reserved: nameReserved } = safeFunctionName(functionName);
+
     // Pure function signature + destructure are built AFTER the body so we
     // can match what the LLM actually references — strict tsc's
     // noUnusedLocals / noUnusedParameters fire on every input the body
@@ -484,7 +494,7 @@ export async function generateAiBehaviorsFile(opts: {
     const buildTestCode = (rawBody: string): string => {
       const { signature, destructure } = buildSignatureAndDestructure(rawBody);
       const destructureLine = destructure ? destructure + '\n' : '';
-      return `export async function ${functionName}(${signature}): Promise<${returnType}> {\n${destructureLine}${rawBody}\n}`;
+      return `export async function ${safeName}(${signature}): Promise<${returnType}> {\n${destructureLine}${rawBody}\n}`;
     };
 
     // Check cache first — skip Claude if we've generated this exact step before
@@ -610,6 +620,9 @@ export async function generateAiBehaviorsFile(opts: {
       ? ` * Returns: ${returnType}\n`
       : '';
 
+    const reExportLine = nameReserved
+      ? `\nexport { ${safeName} as ${functionName} };`
+      : '';
     functions.push(`/**
  * ${functionName}
  *
@@ -628,7 +641,7 @@ ${inputsDoc}${returnsDoc} * Source: ${source}
    ? 'AI returned code with syntax errors — function throws at runtime. Fix or regenerate.'
    : 'STUB — Claude CLI unavailable. Install Claude Code or implement manually.'}
  */
-export async function ${functionName}(${(() => {
+${nameReserved ? 'async' : 'export async'} function ${safeName}(${(() => {
   const { signature: sig } = buildSignatureAndDestructure(body);
   return sig;
 })()}): Promise<${returnType}> {
@@ -636,7 +649,7 @@ ${(() => {
   const { destructure } = buildSignatureAndDestructure(body);
   return destructure ? destructure + '\n' : '';
 })()}${body}
-}`);
+}${reExportLine}`);
   }
 
   // End the session

package/libs/instance-factories/services/templates/prisma/step-conventions.ts

@@ -17,6 +17,7 @@ import {
   type SharedConvention,
   type SharedStepContext,
 } from '../_shared/step-matching.js';
+import { safeEntityName } from '@specverse/types';
 
 export type StepConvention = SharedConvention<StepContext>;
 
@@ -125,13 +126,27 @@ export const STEP_CONVENTIONS: StepConvention[] = [
   },
 
   // --- Find / Lookup ---
+  //
+  // All entity-targeting patterns (find / create / update / delete) share
+  // two safeguards:
+  //   1. A pattern-level leading-adjective skip
+  //      `(?:(?:new|existing|current|the|a|an)\s+)?` so NL phrasings like
+  //      "Find existing Player by id" or "Create new Player with ..."
+  //      extract the noun, not the adjective. Kept in sync with
+  //      `NL_LEADING_ADJECTIVES` in `_shared/step-matching.ts`.
+  //   2. `safeEntityName(m[1])` — the reserved-word-safe primitive from
+  //      `@specverse/types`. Returns the lowerCamel identifier, or `null`
+  //      when the extraction would emit a TS reserved word
+  //      (e.g. `prisma.new.create`). On null, generateCall returns `''` so
+  //      the matcher falls through to the AI [WRITE] fallback.
   {
     name: 'find',
-    pattern: /^find\s+(\w+)\s+by\s+(\w+)/i,
+    pattern: /^find\s+(?:(?:new|existing|current|the|a|an)\s+)?(\w+)\s+by\s+(\w+)/i,
     generateCall: (m, ctx) => {
       const model = m[1];
+      const modelVar = safeEntityName(model);
+      if (!modelVar) return '';
       const field = m[2];
-      const modelVar = toVar(model);
       const params = ctx.parameterNames || [];
       const declared = ctx.declaredVars || new Set();
 
@@ -154,10 +169,11 @@ export const STEP_CONVENTIONS: StepConvention[] = [
   // --- Create ---
   {
     name: 'create',
-    pattern: /^create\s+(\w+)(?:\s+(?:with\s+)?(.+))?/i,
+    pattern: /^create\s+(?:(?:new|existing|current|the|a|an)\s+)?(\w+)(?:\s+(?:with\s+)?(.+))?/i,
     generateCall: (m, ctx) => {
       const model = m[1];
-      const modelVar = toVar(model);
+      const modelVar = safeEntityName(model);
+      if (!modelVar) return '';
       // Build data from parameter names if available
       const paramNames = ctx.parameterNames || [];
       const dataFields = paramNames.length > 0
@@ -171,12 +187,13 @@ export const STEP_CONVENTIONS: StepConvention[] = [
   // --- Update field ---
   {
     name: 'update-field',
-    pattern: /^update\s+(\w+)\s+(\w+)\s+to\s+(.+)/i,
+    pattern: /^update\s+(?:(?:new|existing|current|the|a|an)\s+)?(\w+)\s+(\w+)\s+to\s+(.+)/i,
     generateCall: (m, ctx) => {
       const model = m[1];
+      const modelVar = safeEntityName(model);
+      if (!modelVar) return '';
       const field = m[2];
       const rawValue = m[3];
-      const modelVar = toVar(model);
       const val = resolveValue(rawValue, ctx);
       return `    // Step ${ctx.stepNum}: Update ${model} ${field} to ${rawValue.trim()}
     await prisma.${modelVar}.update({
@@ -189,10 +206,11 @@ export const STEP_CONVENTIONS: StepConvention[] = [
   // --- Generic update ---
   {
     name: 'update',
-    pattern: /^update\s+(\w+)(?:\s+(.+))?/i,
+    pattern: /^update\s+(?:(?:new|existing|current|the|a|an)\s+)?(\w+)(?:\s+(.+))?/i,
     generateCall: (m, ctx) => {
       const model = m[1];
-      const modelVar = toVar(model);
+      const modelVar = safeEntityName(model);
+      if (!modelVar) return '';
       return `    // Step ${ctx.stepNum}: Update ${model}
     await prisma.${modelVar}.update({
       where: { id: ${modelVar}.id },
@@ -204,10 +222,11 @@ export const STEP_CONVENTIONS: StepConvention[] = [
   // --- Delete ---
   {
     name: 'delete',
-    pattern: /^delete\s+(\w+)/i,
+    pattern: /^delete\s+(?:(?:new|existing|current|the|a|an)\s+)?(\w+)/i,
     generateCall: (m, ctx) => {
       const model = m[1];
-      const modelVar = toVar(model);
+      const modelVar = safeEntityName(model);
+      if (!modelVar) return '';
       return `    // Step ${ctx.stepNum}: Delete ${model}
     await prisma.${modelVar}.delete({ where: { id: ${modelVar}.id } });`;
     },
@@ -220,7 +239,8 @@ export const STEP_CONVENTIONS: StepConvention[] = [
     generateCall: (m, ctx) => {
       const model = m[1];
       const state = m[2];
-      const modelVar = toVar(model);
+      const modelVar = safeEntityName(model);
+      if (!modelVar) return '';
       return `    // Step ${ctx.stepNum}: Transition ${model} to ${state}
     if (${modelVar}.status === '${state}') throw new Error('${model} is already ${state}');
     await prisma.${modelVar}.update({
@@ -314,8 +334,10 @@ export const STEP_CONVENTIONS: StepConvention[] = [
     generateCall: (m, ctx) => {
       const service = m[1];
       const method = m[2];
+      const serviceVar = safeEntityName(service);
+      if (!serviceVar) return '';
       return `    // Step ${ctx.stepNum}: Call ${service}.${method}
-    await ${toVar(service)}.${method}({ ${(ctx.parameterNames || []).join(', ')} });`;
+    await ${serviceVar}.${method}({ ${(ctx.parameterNames || []).join(', ')} });`;
     },
   },
 

package/libs/instance-factories/services/templates/shared-patterns.ts

@@ -1,12 +1,22 @@
 /**
  * Shared Convention Pattern Definitions
  *
- * The canonical list of step convention patterns. Both the Prisma factory
- * (code generation) and the Memory factory (runtime interpretation) use
- * these same patterns. Add new patterns here — both targets pick them up.
+ * Canonical pattern list consumed by the Memory factory's runtime
+ * interpreter (`generateInterpreterModule` reads them to emit
+ * dispatch code). Prisma / Mongo / Postgres step-conventions split
+ * off into their own inline-regex files historically and no longer
+ * read from here — changes in this file primarily affect Memory.
  *
- * This is the "interface" of the convention system. Each factory provides
- * the "implementation" (generateCall or execute).
+ * Entity-targeting patterns (find / create / update-field / update /
+ * delete) carry a leading-adjective skip
+ * `(?:(?:new|existing|current|the|a|an)\s+)?` so an NL step like
+ * "Create new Player with …" extracts `Player`, not `new`. Mirrors
+ * `NL_LEADING_ADJECTIVES` in `_shared/step-matching.ts`. Without this,
+ * Memory's interpreter would call `ctx.store.create("new", data)` and
+ * fail at lookup; the structural cause is identical to the TS-side bug
+ * that `safeEntityName` (from `@specverse/types`) addresses in the
+ * other ORMs — only the *consequence* differs (runtime lookup failure
+ * here vs TS syntax error there).
  */
 
 export interface PatternDefinition {
@@ -19,13 +29,13 @@ export const CONVENTION_PATTERNS: PatternDefinition[] = [
   { name: 'validate',         pattern: /^validate\s+(.+)/i,                                    description: 'Validate input data' },
   { name: 'check-no-existing', pattern: /^check\s+(?:no\s+existing|.*has\s+no\s+existing)\s+(\w+)\s+for\s+(\w+)\s+in\s+(\w+)/i, description: 'Check no duplicate entity exists for a pair' },
   { name: 'check',            pattern: /^check\s+(.+)/i,                                       description: 'Check a condition' },
-  { name: 'find',             pattern: /^find\s+(\w+)\s+by\s+(\w+)/i,                          description: 'Find entity by field' },
+  { name: 'find',             pattern: /^find\s+(?:(?:new|existing|current|the|a|an)\s+)?(\w+)\s+by\s+(\w+)/i, description: 'Find entity by field' },
   { name: 'find-all-for',     pattern: /^find\s+(?:all\s+)?(\w+?)s?\s+(?:for|of|belonging\s+to)\s+(\w+)/i, description: 'Cross-model query via foreign key' },
   { name: 'count-per',        pattern: /^count\s+(\w+?)s?\s+(?:per|by|for\s+each)\s+(\w+)/i,   description: 'Group-by aggregation count' },
-  { name: 'create',           pattern: /^create\s+(\w+)(?:\s+record)?/i,                       description: 'Create a new entity' },
-  { name: 'update-field',     pattern: /^update\s+(\w+)\s+(\w+)\s+to\s+(.+)/i,                 description: 'Update specific field to value' },
-  { name: 'update',           pattern: /^update\s+(\w+)$/i,                                    description: 'Update entity with params' },
-  { name: 'delete',           pattern: /^delete\s+(\w+)/i,                                     description: 'Delete an entity' },
+  { name: 'create',           pattern: /^create\s+(?:(?:new|existing|current|the|a|an)\s+)?(\w+)(?:\s+record)?/i, description: 'Create a new entity' },
+  { name: 'update-field',     pattern: /^update\s+(?:(?:new|existing|current|the|a|an)\s+)?(\w+)\s+(\w+)\s+to\s+(.+)/i, description: 'Update specific field to value' },
+  { name: 'update',           pattern: /^update\s+(?:(?:new|existing|current|the|a|an)\s+)?(\w+)$/i, description: 'Update entity with params' },
+  { name: 'delete',           pattern: /^delete\s+(?:(?:new|existing|current|the|a|an)\s+)?(\w+)/i, description: 'Delete an entity' },
   { name: 'transition',       pattern: /^transition\s+(\w+)\s+to\s+(\w+)/i,                    description: 'Lifecycle state transition' },
   { name: 'set',              pattern: /^set\s+(\w+)\s+to\s+(.+)/i,                            description: 'Set a field value' },
   { name: 'increment',        pattern: /^increment\s+(\w+)\s+by\s+(\w+)/i,                     description: 'Increment numeric field' },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specverse/engines",
-  "version": "6.60.1",
+  "version": "6.63.0",
   "description": "SpecVerse toolchain — parser, inference, realize, generators, AI, registry, bundles",
   "type": "module",
   "main": "dist/index.js",

package/libs/instance-factories/services/templates/_shared/step-matching.d.ts

@@ -1,39 +0,0 @@
-/**
- * Shared step-matching machinery — common helpers + the canonical
- * `matchAgainstConventions` walker that any ORM-specific step-conventions
- * library can compose with.
- *
- * Each ORM library (prisma, mongodb-native) exports its own
- * `STEP_CONVENTIONS` array of `{name, pattern, generateCall}` items
- * describing what code to emit for matched patterns. The matcher itself
- * is identical across libraries: walk the conventions in order, first
- * match wins; if nothing matches, compute the AI-fallback shape
- * (functionName + inputs + resultVar) deterministically.
- *
- * Extracted from prisma/step-conventions.ts and mongodb-native/step-conventions.ts
- * so future ORM libraries can drop in just the conventions array
- * without re-implementing matching logic. (#43K-D)
- */
-/** Camel-case a step's text into a TS identifier. Identical algorithm
- * across all ORM libraries — function names emitted in `aiBehaviors.<X>(...)`
- * calls must agree with the function declarations the AI-behaviors-generator
- * emits. Both sides go through this. */
-export declare function toMethod(words: string): string;
-export declare function toVar(name: string): string;
-export type { SharedStepContext, SharedConvention, MatchResult, MatcherFn, } from '@specverse/types';
-import type { SharedStepContext, SharedConvention, MatchResult } from '@specverse/types';
-export interface StepMatchRecord {
-    ownerName: string;
-    actionName: string;
-    stepOrdinal: number;
-    stepText: string;
-    matched: boolean;
-    helperMethod?: string;
-    aiFunctionName?: string;
-}
-export declare function setStepMatchRecorder(fn: ((r: StepMatchRecord) => void) | null): void;
-/** Walk conventions in order. First match wins (with empty-string fallthrough).
- * Unmatched: compute the AI-delegate call site shape so the controller and
- * the AI-behaviors-generator agree on function name + inputs + resultVar. */
-export declare function matchAgainstConventions<C extends SharedStepContext>(step: string, ctx: C, conventions: ReadonlyArray<SharedConvention<C>>, aiArgsExpr: (inputs: string[], paramNames: string[]) => string): MatchResult;
-//# sourceMappingURL=step-matching.d.ts.map

package/libs/instance-factories/services/templates/_shared/step-matching.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"step-matching.d.ts","sourceRoot":"","sources":["step-matching.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH;;;wCAGwC;AACxC,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAK9C;AAED,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE1C;AAMD,YAAY,EACV,iBAAiB,EACjB,gBAAgB,EAChB,WAAW,EACX,SAAS,GACV,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAWzF,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,eAAe,KAAK,IAAI,CAAC,GAAG,IAAI,GAAG,IAAI,CAEpF;AAED;;6EAE6E;AAC7E,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,iBAAiB,EACjE,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,CAAC,EACN,WAAW,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,EAC/C,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,MAAM,GAC7D,WAAW,CAsDb"}

package/libs/instance-factories/services/templates/_shared/step-matching.js

@@ -1,90 +0,0 @@
-/**
- * Shared step-matching machinery — common helpers + the canonical
- * `matchAgainstConventions` walker that any ORM-specific step-conventions
- * library can compose with.
- *
- * Each ORM library (prisma, mongodb-native) exports its own
- * `STEP_CONVENTIONS` array of `{name, pattern, generateCall}` items
- * describing what code to emit for matched patterns. The matcher itself
- * is identical across libraries: walk the conventions in order, first
- * match wins; if nothing matches, compute the AI-fallback shape
- * (functionName + inputs + resultVar) deterministically.
- *
- * Extracted from prisma/step-conventions.ts and mongodb-native/step-conventions.ts
- * so future ORM libraries can drop in just the conventions array
- * without re-implementing matching logic. (#43K-D)
- */
-/** Camel-case a step's text into a TS identifier. Identical algorithm
- * across all ORM libraries — function names emitted in `aiBehaviors.<X>(...)`
- * calls must agree with the function declarations the AI-behaviors-generator
- * emits. Both sides go through this. */
-export function toMethod(words) {
-    const cleaned = words.trim().replace(/[^A-Za-z0-9\s]+/g, ' ');
-    const camel = cleaned.replace(/\s+(.)/g, (_, c) => c.toUpperCase()).replace(/^\w/, (c) => c.toLowerCase());
-    const safe = camel.replace(/[^A-Za-z0-9_$]/g, '');
-    return safe || 'unnamedStep';
-}
-export function toVar(name) {
-    return name.charAt(0).toLowerCase() + name.slice(1);
-}
-let _stepRecorder = null;
-export function setStepMatchRecorder(fn) {
-    _stepRecorder = fn;
-}
-/** Walk conventions in order. First match wins (with empty-string fallthrough).
- * Unmatched: compute the AI-delegate call site shape so the controller and
- * the AI-behaviors-generator agree on function name + inputs + resultVar. */
-export function matchAgainstConventions(step, ctx, conventions, aiArgsExpr) {
-    let result = null;
-    for (const convention of conventions) {
-        const m = step.match(convention.pattern);
-        if (m) {
-            const call = convention.generateCall(m, ctx);
-            if (call) {
-                result = {
-                    matched: true,
-                    call,
-                    helperMethod: convention.generateMethod?.(m, ctx),
-                };
-                break;
-            }
-        }
-    }
-    if (!result) {
-        // AI fallback shape — same across all ORMs.
-        const functionName = toMethod(step);
-        const declared = Array.from(ctx.declaredVars || []);
-        const paramNames = ctx.parameterNames || [];
-        const inputs = [...paramNames, ...declared];
-        const resultVar = ctx.resultName || `step${ctx.stepNum}Result`;
-        if (ctx.declaredVars)
-            ctx.declaredVars.add(resultVar);
-        const inputObj = aiArgsExpr(inputs, paramNames);
-        result = {
-            matched: false,
-            call: `    // Step ${ctx.stepNum}: ${step} [AI-generated — pure transform]
-    const ${resultVar} = await aiBehaviors.${functionName}(${inputObj});`,
-            functionName,
-            inputs,
-            resultVar,
-        };
-    }
-    // Forward-log the decision. ctx.serviceName carries the spec owner
-    // (controller or service — the shared context uses one field for both).
-    if (_stepRecorder) {
-        try {
-            _stepRecorder({
-                ownerName: ctx.serviceName,
-                actionName: ctx.operationName,
-                stepOrdinal: ctx.stepNum,
-                stepText: step,
-                matched: result.matched,
-                helperMethod: result.helperMethod,
-                aiFunctionName: result.functionName,
-            });
-        }
-        catch { /* recorder must never break generation */ }
-    }
-    return result;
-}
-//# sourceMappingURL=step-matching.js.map

package/libs/instance-factories/services/templates/_shared/step-matching.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"step-matching.js","sourceRoot":"","sources":["step-matching.ts"],"names":[],"mappings":"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"}