@lokascript/framework 2.8.0 → 2.9.1

package/src/generation/pattern-generator.test.ts

@@ -71,6 +71,108 @@ describe('PatternGenerator', () => {
       expect(pattern.template.tokens[1]).toEqual({ type: 'literal', value: 'トグル' });
     });
 
+    it('should place a sovSlot:postVerb role after the verb in SOV', () => {
+      // The renderer buckets by this field (`renderer.ts`), writing voice's
+      // page count after the verb: `戻る 2`. Generation has to agree, or the
+      // rendered surface re-parses as a bare verb with its argument dropped.
+      const schema = defineCommand({
+        action: 'back',
+        roles: [
+          defineRole({
+            role: 'quantity',
+            required: true,
+            expectedTypes: ['expression'],
+            sovPosition: 1,
+            sovSlot: 'postVerb',
+          }),
+        ],
+      });
+
+      const profile: PatternGenLanguageProfile = {
+        code: 'ja',
+        wordOrder: 'SOV',
+        keywords: { back: { primary: '戻る' } },
+      };
+
+      const pattern = generatePattern(schema, profile);
+
+      expect(pattern.template.tokens).toHaveLength(2);
+      expect(pattern.template.tokens[0]).toEqual({ type: 'literal', value: '戻る' });
+      expect(pattern.template.tokens[1]).toMatchObject({ type: 'role', role: 'quantity' });
+      expect(pattern.template.format).toBe('戻る {quantity}');
+    });
+
+    it('should split pre-verb and post-verb roles around the verb in SOV', () => {
+      const schema = defineCommand({
+        action: 'fetch',
+        roles: [
+          defineRole({
+            role: 'source',
+            required: true,
+            expectedTypes: ['expression'],
+            sovPosition: 2,
+          }),
+          defineRole({
+            role: 'destination',
+            required: true,
+            expectedTypes: ['selector'],
+            sovPosition: 1,
+            sovSlot: 'postVerb',
+            markerOverride: { ja: 'に' },
+          }),
+        ],
+      });
+
+      const profile: PatternGenLanguageProfile = {
+        code: 'ja',
+        wordOrder: 'SOV',
+        keywords: { fetch: { primary: '取得' } },
+      };
+
+      const pattern = generatePattern(schema, profile);
+
+      expect(pattern.template.tokens).toEqual([
+        expect.objectContaining({ type: 'role', role: 'source' }),
+        { type: 'literal', value: '取得' },
+        expect.objectContaining({ type: 'role', role: 'destination' }),
+        // SOV markers default to following their value
+        { type: 'literal', value: 'に' },
+      ]);
+      // The role PHRASE moves as a unit. Note the marker sits before its role
+      // here while the tokens put it after: `format` resolves marker position
+      // from the profile alone, missing `markerPosition` and the SOV default
+      // that `addRoleWithMarker` applies. Pre-existing and documentation-only
+      // (nothing reads `format`), left alone deliberately — fixing it would
+      // move every SOV golden entry with a marker and bury this change's diff.
+      expect(pattern.template.format).toBe('{source} 取得 に {destination}');
+    });
+
+    it('should ignore sovSlot outside SOV languages', () => {
+      const schema = defineCommand({
+        action: 'back',
+        roles: [
+          defineRole({
+            role: 'quantity',
+            required: true,
+            expectedTypes: ['expression'],
+            svoPosition: 1,
+            sovSlot: 'postVerb',
+          }),
+        ],
+      });
+
+      for (const wordOrder of ['SVO', 'VSO'] as const) {
+        const pattern = generatePattern(schema, {
+          code: 'en',
+          wordOrder,
+          keywords: { back: { primary: 'back' } },
+        });
+
+        expect(pattern.template.tokens[0]).toEqual({ type: 'literal', value: 'back' });
+        expect(pattern.template.tokens[1]).toMatchObject({ type: 'role', role: 'quantity' });
+      }
+    });
+
     it('should generate a VSO pattern with verb first', () => {
       const schema = defineCommand({
         action: 'toggle',

package/src/generation/pattern-generator.ts

@@ -110,15 +110,21 @@ function buildTokens(
       addRoleWithMarker(tokens, role, profile);
     }
   }
-  // For SOV: [patient, destination, source, ..., action]
+  // For SOV: [patient, destination, source, ..., action, postVerb roles...]
   else if (profile.wordOrder === 'SOV') {
-    // Add roles with markers first
+    // `sovSlot: 'postVerb'` moves a role AFTER the verb, which is what the
+    // renderer does (`renderer.ts` buckets by the same field). Generation has
+    // to mirror it: a role the renderer writes post-verb but the pattern
+    // expects pre-verb produces a faithful surface its own parser drops the
+    // argument from — voice's `戻る 2` re-parsing as a bare `back`.
+    const preVerb: PatternToken[] = [];
+    const postVerb: PatternToken[] = [];
+
     for (const role of sortedRoles) {
-      addRoleWithMarker(tokens, role, profile);
+      addRoleWithMarker(role.sovSlot === 'postVerb' ? postVerb : preVerb, role, profile);
     }
 
-    // Add keyword last
-    tokens.push(keywordToken);
+    tokens.push(...preVerb, keywordToken, ...postVerb);
   }
   // For VSO: [action, destination, patient, source, ...]
   else if (profile.wordOrder === 'VSO') {
@@ -218,8 +224,11 @@ function getMarkerForRole(
 
 /**
  * Sort roles by word order for pattern building.
+ *
+ * Exported so the renderer sorts with exactly this comparator — a rendered
+ * surface whose role order differs from the generated pattern would not re-parse.
  */
-function sortRolesByWordOrder(roles: RoleSpec[], wordOrder: string): RoleSpec[] {
+export function sortRolesByWordOrder(roles: RoleSpec[], wordOrder: string): RoleSpec[] {
   const sorted = [...roles];
 
   if (wordOrder === 'SVO') {
@@ -266,11 +275,9 @@ function buildFormatString(
   profile: PatternGenLanguageProfile,
   keyword: string
 ): string {
-  const parts: string[] = [];
-
-  if (profile.wordOrder === 'SVO' || profile.wordOrder === 'VSO') {
-    parts.push(keyword);
-  }
+  const isSOV = profile.wordOrder === 'SOV';
+  const preVerb: string[] = [];
+  const postVerb: string[] = [];
 
   // Order roles the same way buildTokens does (descending position). Iterating
   // declaration order here would disagree with the token order whenever a
@@ -279,24 +286,25 @@ function buildFormatString(
   for (const role of sortedRoles) {
     const marker = getMarkerForRole(role, profile);
     const roleName = `{${role.role}}`;
+    // Same pre/post-verb split buildTokens applies, so the documented format
+    // string keeps describing the tokens it is generated alongside.
+    const bucket = isSOV && role.sovSlot === 'postVerb' ? postVerb : preVerb;
 
     if (marker) {
       const markerInfo = profile.roleMarkers?.[role.role];
       if (markerInfo?.position === 'after') {
-        parts.push(`${roleName} ${marker}`);
+        bucket.push(`${roleName} ${marker}`);
       } else {
-        parts.push(`${marker} ${roleName}`);
+        bucket.push(`${marker} ${roleName}`);
       }
     } else {
-      parts.push(roleName);
+      bucket.push(roleName);
     }
   }
 
-  if (profile.wordOrder === 'SOV') {
-    parts.push(keyword);
-  }
-
-  return parts.join(' ');
+  return (isSOV ? [...preVerb, keyword, ...postVerb] : [keyword, ...preVerb, ...postVerb]).join(
+    ' '
+  );
 }
 
 /**

package/src/generation/renderer.test.ts

@@ -168,6 +168,8 @@ describe('detectWordOrders', () => {
 // =============================================================================
 
 describe('createSchemaRenderer', () => {
+  // Positions sort DESCENDING (higher = earlier), matching pattern generation:
+  // columns (2) precedes source (1) → "select name from users".
   const schemas: CommandSchema[] = [
     defineCommand({
       action: 'select',
@@ -179,13 +181,13 @@ describe('createSchemaRenderer', () => {
           role: 'columns',
           required: true,
           expectedTypes: ['expression'],
-          svoPosition: 1,
+          svoPosition: 2,
         }),
         defineRole({
           role: 'source',
           required: true,
           expectedTypes: ['expression'],
-          svoPosition: 2,
+          svoPosition: 1,
           markerOverride: { en: 'from', ja: 'から' },
         }),
       ],
@@ -239,7 +241,7 @@ describe('createSchemaRenderer', () => {
             role: 'columns',
             required: true,
             expectedTypes: ['expression'],
-            svoPosition: 1,
+            svoPosition: 3,
           }),
           defineRole({
             role: 'source',
@@ -252,7 +254,7 @@ describe('createSchemaRenderer', () => {
             role: 'condition',
             required: false,
             expectedTypes: ['expression'],
-            svoPosition: 3,
+            svoPosition: 1,
             markerOverride: { en: 'where' },
           }),
         ],
@@ -263,4 +265,241 @@ describe('createSchemaRenderer', () => {
     const node = makeNode('select', { columns: 'name', source: 'users' });
     expect(renderer.render(node, 'en')).toBe('select name from users');
   });
+
+  describe('absent roles never leave a dangling marker', () => {
+    // An "analyze"-shaped schema: `manner` is REQUIRED and marked, so a node
+    // missing it used to render "analyze #content as" / "#content として 分析".
+    const analyzeSchemas: CommandSchema[] = [
+      defineCommand({
+        action: 'analyze',
+        description: 'Analyze content',
+        category: 'llm',
+        primaryRole: 'patient',
+        roles: [
+          defineRole({
+            role: 'patient',
+            required: true,
+            expectedTypes: ['expression'],
+            svoPosition: 2,
+          }),
+          defineRole({
+            role: 'manner',
+            required: true,
+            expectedTypes: ['expression'],
+            svoPosition: 1,
+            markerOverride: { en: 'as', ja: 'として' },
+          }),
+        ],
+      }),
+    ];
+
+    const analyzeProfiles: PatternGenLanguageProfile[] = [
+      {
+        code: 'en',
+        wordOrder: 'SVO',
+        keywords: { analyze: { primary: 'analyze' } },
+        roleMarkers: {},
+      },
+      { code: 'ja', wordOrder: 'SOV', keywords: { analyze: { primary: '分析' } }, roleMarkers: {} },
+    ];
+
+    it('omits a required-but-absent role and its marker (SVO)', () => {
+      const renderer = createSchemaRenderer(analyzeSchemas, analyzeProfiles);
+      const node = makeNode('analyze', { patient: '#content' });
+      expect(renderer.render(node, 'en')).toBe('analyze #content');
+    });
+
+    it('omits a required-but-absent role and its marker (SOV)', () => {
+      const renderer = createSchemaRenderer(analyzeSchemas, analyzeProfiles);
+      const node = makeNode('analyze', { patient: '#content' });
+      expect(renderer.render(node, 'ja')).toBe('#content 分析');
+    });
+
+    it('still renders the marker when the role has a value', () => {
+      const renderer = createSchemaRenderer(analyzeSchemas, analyzeProfiles);
+      const node = makeNode('analyze', { patient: '#content', manner: 'sentiment' });
+      expect(renderer.render(node, 'en')).toBe('analyze #content as sentiment');
+    });
+  });
+
+  describe('role positions', () => {
+    // Declaration order deliberately disagrees with the declared positions.
+    const outOfOrder: CommandSchema[] = [
+      defineCommand({
+        action: 'select',
+        description: 'Select data',
+        category: 'query',
+        primaryRole: 'columns',
+        roles: [
+          defineRole({
+            role: 'source',
+            required: true,
+            expectedTypes: ['expression'],
+            svoPosition: 1,
+            sovPosition: 1,
+            markerOverride: { en: 'from', ja: 'から' },
+          }),
+          defineRole({
+            role: 'columns',
+            required: true,
+            expectedTypes: ['expression'],
+            svoPosition: 2,
+            sovPosition: 2,
+          }),
+        ],
+      }),
+    ];
+
+    it('orders roles by svoPosition, not declaration order', () => {
+      const renderer = createSchemaRenderer(outOfOrder, profiles);
+      const node = makeNode('select', { columns: 'name', source: 'users' });
+      expect(renderer.render(node, 'en')).toBe('select name from users');
+    });
+
+    it('orders roles by sovPosition for SOV languages', () => {
+      const renderer = createSchemaRenderer(outOfOrder, profiles);
+      const node = makeNode('select', { columns: 'name', source: 'users' });
+      expect(renderer.render(node, 'ja')).toBe('name users から 選択');
+    });
+  });
+
+  describe('role defaults', () => {
+    const withDefault: CommandSchema[] = [
+      defineCommand({
+        action: 'select',
+        description: 'Select data',
+        category: 'query',
+        primaryRole: 'columns',
+        roles: [
+          defineRole({
+            role: 'columns',
+            required: true,
+            expectedTypes: ['expression'],
+            svoPosition: 2,
+            default: { type: 'literal', value: '*' },
+          }),
+          defineRole({
+            role: 'source',
+            required: true,
+            expectedTypes: ['expression'],
+            svoPosition: 1,
+            markerOverride: { en: 'from' },
+          }),
+        ],
+      }),
+    ];
+
+    it("renders a schema default in an absent role's place", () => {
+      const renderer = createSchemaRenderer(withDefault, profiles);
+      const node = makeNode('select', { source: 'users' });
+      expect(renderer.render(node, 'en')).toBe('select * from users');
+    });
+
+    it('prefers the node value over the default', () => {
+      const renderer = createSchemaRenderer(withDefault, profiles);
+      const node = makeNode('select', { columns: 'name', source: 'users' });
+      expect(renderer.render(node, 'en')).toBe('select name from users');
+    });
+  });
+
+  describe('marker placement and formatting', () => {
+    const capabilities: CommandSchema[] = [
+      defineCommand({
+        action: 'summarize',
+        description: 'Summarize content',
+        category: 'llm',
+        primaryRole: 'patient',
+        roles: [
+          defineRole({
+            role: 'patient',
+            required: true,
+            expectedTypes: ['expression'],
+            svoPosition: 3,
+            sovPosition: 3,
+            quoteMultiword: true,
+          }),
+          defineRole({
+            role: 'quantity',
+            required: false,
+            expectedTypes: ['expression'],
+            svoPosition: 2,
+            sovPosition: 2,
+            markerOverride: { en: 'in', ja: 'で' },
+            // Japanese renders this marker BEFORE its value despite SOV default
+            markerPositionOverride: { ja: 'before' },
+          }),
+          defineRole({
+            role: 'manner',
+            required: false,
+            expectedTypes: ['expression'],
+            svoPosition: 1,
+            sovPosition: 1,
+            markerOverride: { en: 'as', ja: 'として' },
+            sovSlot: 'postVerb',
+          }),
+          defineRole({
+            role: 'source',
+            required: false,
+            expectedTypes: ['expression'],
+            svoPosition: 0,
+            markerOverride: { en: '' }, // parser-only marker; renders bare
+          }),
+        ],
+      }),
+    ];
+
+    const capProfiles: PatternGenLanguageProfile[] = [
+      {
+        code: 'en',
+        wordOrder: 'SVO',
+        keywords: { summarize: { primary: 'summarize' } },
+        roleMarkers: {},
+      },
+      {
+        code: 'ja',
+        wordOrder: 'SOV',
+        keywords: { summarize: { primary: '要約' } },
+        roleMarkers: {},
+      },
+    ];
+
+    it('quotes a multi-word value for quoteMultiword roles', () => {
+      const renderer = createSchemaRenderer(capabilities, capProfiles);
+      const node = makeNode('summarize', { patient: 'the annual report' });
+      expect(renderer.render(node, 'en')).toBe('summarize "the annual report"');
+    });
+
+    it('leaves a single-word value unquoted', () => {
+      const renderer = createSchemaRenderer(capabilities, capProfiles);
+      const node = makeNode('summarize', { patient: '#document' });
+      expect(renderer.render(node, 'en')).toBe('summarize #document');
+    });
+
+    it('does not double-quote an already-quoted value', () => {
+      const renderer = createSchemaRenderer(capabilities, capProfiles);
+      const node = makeNode('summarize', { patient: '"the annual report"' });
+      expect(renderer.render(node, 'en')).toBe('summarize "the annual report"');
+    });
+
+    it('honors markerPositionOverride against the word-order default', () => {
+      const renderer = createSchemaRenderer(capabilities, capProfiles);
+      const node = makeNode('summarize', { patient: '#doc', quantity: '3' });
+      // ja default would be "3 で"; the override puts the marker first
+      expect(renderer.render(node, 'ja')).toBe('#doc で 3 要約');
+    });
+
+    it('renders a sovSlot:postVerb role after the verb', () => {
+      const renderer = createSchemaRenderer(capabilities, capProfiles);
+      const node = makeNode('summarize', { patient: '#doc', manner: 'bullets' });
+      expect(renderer.render(node, 'ja')).toBe('#doc 要約 bullets として');
+      // SVO is unaffected — sovSlot applies only to SOV languages
+      expect(renderer.render(node, 'en')).toBe('summarize #doc as bullets');
+    });
+
+    it("treats renderOverride '' as no marker", () => {
+      const renderer = createSchemaRenderer(capabilities, capProfiles);
+      const node = makeNode('summarize', { patient: '#doc', source: '#feed' });
+      expect(renderer.render(node, 'en')).toBe('summarize #doc #feed');
+    });
+  });
 });