@lokascript/semantic 1.0.0 → 1.1.0

package/src/patterns/add/ar.ts

@@ -1,8 +1,8 @@
 /**
  * Arabic Add Patterns
  *
- * Hand-crafted patterns for "add" command.
- * Arabic uses VSO order: أضف {patient} إلى {target}
+ * Strategy: Return empty array to rely on auto-generated patterns from profile.
+ * This follows the Tagalog model which achieves 100% pass rate with pure generation.
  */
 
 import type { LanguagePattern } from '../../types';
@@ -11,61 +11,5 @@ import type { LanguagePattern } from '../../types';
  * Get Arabic add patterns.
  */
 export function getAddPatternsAr(): LanguagePattern[] {
-  return [
-    {
-      id: 'add-ar-full',
-      language: 'ar',
-      command: 'add',
-      priority: 100,
-      template: {
-        format: 'أضف {patient} إلى {destination}',
-        tokens: [
-          { type: 'literal', value: 'أضف', alternatives: ['اضف', 'أضيف', 'اضافة'] },
-          { type: 'role', role: 'patient' },
-          { type: 'literal', value: 'إلى', alternatives: ['الى', 'ل', 'لـ'] },
-          { type: 'role', role: 'destination' },
-        ],
-      },
-      extraction: {
-        patient: { position: 1 },
-        destination: { marker: 'إلى', markerAlternatives: ['الى', 'ل', 'لـ'] },
-      },
-    },
-    {
-      id: 'add-ar-simple',
-      language: 'ar',
-      command: 'add',
-      priority: 90,
-      template: {
-        format: 'أضف {patient}',
-        tokens: [
-          { type: 'literal', value: 'أضف', alternatives: ['اضف', 'أضيف'] },
-          { type: 'role', role: 'patient' },
-        ],
-      },
-      extraction: {
-        patient: { position: 1 },
-        destination: { default: { type: 'reference', value: 'me' } },
-      },
-    },
-    {
-      id: 'add-ar-with-على',
-      language: 'ar',
-      command: 'add',
-      priority: 95,
-      template: {
-        format: 'أضف {patient} على {destination}',
-        tokens: [
-          { type: 'literal', value: 'أضف', alternatives: ['اضف'] },
-          { type: 'role', role: 'patient' },
-          { type: 'literal', value: 'على' },
-          { type: 'role', role: 'destination' },
-        ],
-      },
-      extraction: {
-        patient: { position: 1 },
-        destination: { marker: 'على' },
-      },
-    },
-  ];
+  return [];
 }

package/src/patterns/add/index.ts

@@ -16,6 +16,7 @@ import { getAddPatternsJa } from './ja';
 import { getAddPatternsKo } from './ko';
 import { getAddPatternsMs } from './ms';
 import { getAddPatternsPl } from './pl';
+import { getAddPatternsQu } from './qu';
 import { getAddPatternsRu } from './ru';
 import { getAddPatternsTh } from './th';
 import { getAddPatternsTl } from './tl';
@@ -45,6 +46,8 @@ export function getAddPatternsForLanguage(language: string): LanguagePattern[] {
       return getAddPatternsMs();
     case 'pl':
       return getAddPatternsPl();
+    case 'qu':
+      return getAddPatternsQu();
     case 'ru':
       return getAddPatternsRu();
     case 'th':
@@ -73,6 +76,7 @@ export { getAddPatternsJa } from './ja';
 export { getAddPatternsKo } from './ko';
 export { getAddPatternsMs } from './ms';
 export { getAddPatternsPl } from './pl';
+export { getAddPatternsQu } from './qu';
 export { getAddPatternsRu } from './ru';
 export { getAddPatternsTh } from './th';
 export { getAddPatternsTl } from './tl';
@@ -84,4 +88,4 @@ export { getAddPatternsZh } from './zh';
 /**
  * Languages that have hand-crafted add patterns.
  */
-export const addPatternLanguages = ['ar', 'bn', 'hi', 'it', 'ja', 'ko', 'ms', 'pl', 'ru', 'th', 'tl', 'tr', 'uk', 'vi', 'zh'];
+export const addPatternLanguages = ['ar', 'bn', 'hi', 'it', 'ja', 'ko', 'ms', 'pl', 'qu', 'ru', 'th', 'tl', 'tr', 'uk', 'vi', 'zh'];

package/src/patterns/add/ja.ts

@@ -1,8 +1,8 @@
 /**
  * Japanese Add Patterns
  *
- * Hand-crafted patterns for "add" command.
- * Japanese uses SOV order: {target} に {patient} を 追加
+ * Relying on auto-generated patterns from profile.
+ * Empty stub follows Hindi/Tagalog model for simpler implementation.
  */
 
 import type { LanguagePattern } from '../../types';
@@ -11,83 +11,5 @@ import type { LanguagePattern } from '../../types';
  * Get Japanese add patterns.
  */
 export function getAddPatternsJa(): LanguagePattern[] {
-  return [
-    {
-      id: 'add-ja-full',
-      language: 'ja',
-      command: 'add',
-      priority: 100,
-      template: {
-        format: '{destination} に {patient} を 追加',
-        tokens: [
-          { type: 'role', role: 'destination' },
-          { type: 'literal', value: 'に' },
-          { type: 'role', role: 'patient' },
-          { type: 'literal', value: 'を' },
-          { type: 'literal', value: '追加', alternatives: ['追加する', '加える'] },
-        ],
-      },
-      extraction: {
-        destination: { position: 0 },
-        patient: { marker: 'を' },
-      },
-    },
-    {
-      id: 'add-ja-simple',
-      language: 'ja',
-      command: 'add',
-      priority: 90,
-      template: {
-        format: '{patient} を 追加',
-        tokens: [
-          { type: 'role', role: 'patient' },
-          { type: 'literal', value: 'を' },
-          { type: 'literal', value: '追加', alternatives: ['追加する', '加える'] },
-        ],
-      },
-      extraction: {
-        patient: { position: 0 },
-        destination: { default: { type: 'reference', value: 'me' } },
-      },
-    },
-    {
-      id: 'add-ja-possessive',
-      language: 'ja',
-      command: 'add',
-      priority: 95,
-      template: {
-        format: '{destination} の {patient} を 追加',
-        tokens: [
-          { type: 'role', role: 'destination' },
-          { type: 'literal', value: 'の' },
-          { type: 'role', role: 'patient' },
-          { type: 'literal', value: 'を' },
-          { type: 'literal', value: '追加', alternatives: ['追加する'] },
-        ],
-      },
-      extraction: {
-        destination: { position: 0 },
-        patient: { marker: 'を' },
-      },
-    },
-    // Phase 6d: Word order flexibility - verb-first pattern
-    {
-      id: 'add-ja-verb-first',
-      language: 'ja',
-      command: 'add',
-      priority: 75,
-      template: {
-        format: '追加 {patient} を',
-        tokens: [
-          { type: 'literal', value: '追加', alternatives: ['追加する'] },
-          { type: 'role', role: 'patient' },
-          { type: 'literal', value: 'を' },
-        ],
-      },
-      extraction: {
-        patient: { position: 1 },
-        destination: { default: { type: 'reference', value: 'me' } },
-      },
-    },
-  ];
+  return [];
 }

package/src/patterns/add/ko.ts

@@ -1,8 +1,8 @@
 /**
  * Korean Add Patterns
  *
- * Hand-crafted patterns for "add" command.
- * Korean uses SOV order: {target} 에 {patient} 를 추가
+ * Strategy: Return empty array to rely on auto-generated patterns from profile.
+ * This follows the Tagalog model which achieves 100% pass rate with pure generation.
  */
 
 import type { LanguagePattern } from '../../types';
@@ -11,64 +11,5 @@ import type { LanguagePattern } from '../../types';
  * Get Korean add patterns.
  */
 export function getAddPatternsKo(): LanguagePattern[] {
-  return [
-    {
-      id: 'add-ko-full',
-      language: 'ko',
-      command: 'add',
-      priority: 100,
-      template: {
-        format: '{destination} 에 {patient} 를 추가',
-        tokens: [
-          { type: 'role', role: 'destination' },
-          { type: 'literal', value: '에' },
-          { type: 'role', role: 'patient' },
-          { type: 'literal', value: '를', alternatives: ['을'] },
-          { type: 'literal', value: '추가', alternatives: ['추가하다', '추가해', '더하다'] },
-        ],
-      },
-      extraction: {
-        destination: { position: 0 },
-        patient: { marker: '를', markerAlternatives: ['을'] },
-      },
-    },
-    {
-      id: 'add-ko-simple',
-      language: 'ko',
-      command: 'add',
-      priority: 90,
-      template: {
-        format: '{patient} 를 추가',
-        tokens: [
-          { type: 'role', role: 'patient' },
-          { type: 'literal', value: '를', alternatives: ['을'] },
-          { type: 'literal', value: '추가', alternatives: ['추가하다', '추가해'] },
-        ],
-      },
-      extraction: {
-        patient: { position: 0 },
-        destination: { default: { type: 'reference', value: 'me' } },
-      },
-    },
-    {
-      id: 'add-ko-possessive',
-      language: 'ko',
-      command: 'add',
-      priority: 95,
-      template: {
-        format: '{destination} 의 {patient} 를 추가',
-        tokens: [
-          { type: 'role', role: 'destination' },
-          { type: 'literal', value: '의' },
-          { type: 'role', role: 'patient' },
-          { type: 'literal', value: '를', alternatives: ['을'] },
-          { type: 'literal', value: '추가', alternatives: ['추가하다'] },
-        ],
-      },
-      extraction: {
-        destination: { position: 0 },
-        patient: { marker: '를', markerAlternatives: ['을'] },
-      },
-    },
-  ];
+  return [];
 }

package/src/patterns/add/qu.ts

@@ -0,0 +1,69 @@
+/**
+ * Quechua Add Patterns
+ *
+ * Patterns for parsing "add" command in Quechua (Runasimi).
+ * SOV word order with postposition suffixes (-ta for patient, -man for destination).
+ */
+
+import type { LanguagePattern } from '../../types';
+
+export function getAddPatternsQu(): LanguagePattern[] {
+  return [
+    // SOV pattern: .active ta yapay (patient + verb)
+    {
+      id: 'add-qu-sov',
+      language: 'qu',
+      command: 'add',
+      priority: 100,
+      template: {
+        format: '{patient} ta yapay',
+        tokens: [
+          { type: 'role', role: 'patient' },
+          { type: 'literal', value: 'ta' },
+          { type: 'literal', value: 'yapay', alternatives: ['yapaykuy'] },
+        ],
+      },
+      extraction: {
+        patient: { position: 0 },
+      },
+    },
+    // Simple pattern: yapay .active (verb + patient, more casual)
+    {
+      id: 'add-qu-simple',
+      language: 'qu',
+      command: 'add',
+      priority: 90,
+      template: {
+        format: 'yapay {patient}',
+        tokens: [
+          { type: 'literal', value: 'yapay', alternatives: ['yapaykuy'] },
+          { type: 'role', role: 'patient' },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+      },
+    },
+    // With destination: #button man .active ta yapay
+    {
+      id: 'add-qu-with-dest',
+      language: 'qu',
+      command: 'add',
+      priority: 95,
+      template: {
+        format: '{destination} man {patient} ta yapay',
+        tokens: [
+          { type: 'role', role: 'destination' },
+          { type: 'literal', value: 'man' },
+          { type: 'role', role: 'patient' },
+          { type: 'literal', value: 'ta' },
+          { type: 'literal', value: 'yapay', alternatives: ['yapaykuy'] },
+        ],
+      },
+      extraction: {
+        destination: { position: 0 },
+        patient: { position: 2 },
+      },
+    },
+  ];
+}

package/src/patterns/add/tr.ts

@@ -1,8 +1,8 @@
 /**
  * Turkish Add Patterns
  *
- * Hand-crafted patterns for "add" command.
- * Turkish uses SOV order: {target}'a {patient} ekle
+ * Strategy: Return empty array to rely on auto-generated patterns from profile.
+ * This follows the Tagalog model which achieves 100% pass rate with pure generation.
  */
 
 import type { LanguagePattern } from '../../types';
@@ -11,61 +11,5 @@ import type { LanguagePattern } from '../../types';
  * Get Turkish add patterns.
  */
 export function getAddPatternsTr(): LanguagePattern[] {
-  return [
-    {
-      id: 'add-tr-full',
-      language: 'tr',
-      command: 'add',
-      priority: 100,
-      template: {
-        format: "{destination}'a {patient} ekle",
-        tokens: [
-          { type: 'role', role: 'destination' },
-          { type: 'literal', value: "'a", alternatives: ["'e", "'ya", "'ye", '-a', '-e'] },
-          { type: 'role', role: 'patient' },
-          { type: 'literal', value: 'ekle', alternatives: ['eklemek', 'ekler'] },
-        ],
-      },
-      extraction: {
-        destination: { position: 0 },
-        patient: { position: 2 },
-      },
-    },
-    {
-      id: 'add-tr-simple',
-      language: 'tr',
-      command: 'add',
-      priority: 90,
-      template: {
-        format: '{patient} ekle',
-        tokens: [
-          { type: 'role', role: 'patient' },
-          { type: 'literal', value: 'ekle', alternatives: ['eklemek'] },
-        ],
-      },
-      extraction: {
-        patient: { position: 0 },
-        destination: { default: { type: 'reference', value: 'me' } },
-      },
-    },
-    {
-      id: 'add-tr-locative',
-      language: 'tr',
-      command: 'add',
-      priority: 95,
-      template: {
-        format: '{destination} için {patient} ekle',
-        tokens: [
-          { type: 'role', role: 'destination' },
-          { type: 'literal', value: 'için' },
-          { type: 'role', role: 'patient' },
-          { type: 'literal', value: 'ekle', alternatives: ['eklemek'] },
-        ],
-      },
-      extraction: {
-        destination: { position: 0 },
-        patient: { position: 2 },
-      },
-    },
-  ];
+  return [];
 }

package/src/patterns/builders.ts

@@ -185,6 +185,7 @@ const handcraftedLanguages = [
   'th',
   'ms',
   'tl',
+  'he',
 ];
 
 /**

package/src/patterns/decrement/tr.ts

@@ -1,8 +1,8 @@
 /**
  * Turkish Decrement Patterns
  *
- * Hand-crafted patterns for "decrement" command.
- * Turkish: counter azalt (SOV order)
+ * Strategy: Return empty array to rely on auto-generated patterns from profile.
+ * This follows the Tagalog model which achieves 100% pass rate with pure generation.
  */
 
 import type { LanguagePattern } from '../../types';
@@ -11,38 +11,5 @@ import type { LanguagePattern } from '../../types';
  * Get Turkish decrement patterns.
  */
 export function getDecrementPatternsTr(): LanguagePattern[] {
-  return [
-    {
-      id: 'decrement-tr-full',
-      language: 'tr',
-      command: 'decrement',
-      priority: 100,
-      template: {
-        format: '{patient} azalt',
-        tokens: [
-          { type: 'role', role: 'patient', expectedTypes: ['selector', 'reference', 'expression'] },
-          { type: 'literal', value: 'azalt', alternatives: ['azaltmak', 'düşür', 'decrement'] },
-        ],
-      },
-      extraction: {
-        patient: { position: 0 },
-      },
-    },
-    {
-      id: 'decrement-tr-svo',
-      language: 'tr',
-      command: 'decrement',
-      priority: 90,
-      template: {
-        format: 'azalt {patient}',
-        tokens: [
-          { type: 'literal', value: 'azalt', alternatives: ['azaltmak'] },
-          { type: 'role', role: 'patient', expectedTypes: ['selector', 'reference', 'expression'] },
-        ],
-      },
-      extraction: {
-        patient: { position: 1 },
-      },
-    },
-  ];
+  return [];
 }

package/src/patterns/event-handler/ar.ts

@@ -1,7 +1,8 @@
 /**
  * Arabic Event Handler Patterns
  *
- * Tree-shakeable: Only included when Arabic is imported.
+ * Strategy: Return empty array to rely on auto-generated patterns from profile.
+ * This follows the Tagalog model which achieves 100% pass rate with pure generation.
  */
 
 import type { LanguagePattern } from '../../types';
@@ -10,142 +11,5 @@ import type { LanguagePattern } from '../../types';
  * Get Arabic event handler patterns.
  */
 export function getEventHandlerPatternsAr(): LanguagePattern[] {
-  return [
-    {
-      id: 'event-ar-temporal-source',
-      language: 'ar',
-      command: 'on',
-      priority: 115,
-      template: {
-        format: 'عندما {event} من {source} {body}',
-        tokens: [
-          { type: 'literal', value: 'عندما', alternatives: ['حين', 'لمّا'] },
-          { type: 'role', role: 'event' },
-          { type: 'literal', value: 'من' },
-          { type: 'role', role: 'source' },
-        ],
-      },
-      extraction: {
-        event: { position: 1 },
-        source: { marker: 'من' },
-      },
-    },
-    {
-      id: 'event-ar-temporal-indama',
-      language: 'ar',
-      command: 'on',
-      priority: 105,
-      template: {
-        format: 'عندما {event} {body}',
-        tokens: [
-          { type: 'literal', value: 'عندما' },
-          { type: 'role', role: 'event' },
-        ],
-      },
-      extraction: {
-        event: { position: 1 },
-      },
-    },
-    {
-      id: 'event-ar-temporal-lamma',
-      language: 'ar',
-      command: 'on',
-      priority: 103,
-      template: {
-        format: 'لمّا {event} {body}',
-        tokens: [
-          { type: 'literal', value: 'لمّا', alternatives: ['لما'] },
-          { type: 'role', role: 'event' },
-        ],
-      },
-      extraction: {
-        event: { position: 1 },
-      },
-    },
-    {
-      id: 'event-ar-temporal-hina',
-      language: 'ar',
-      command: 'on',
-      priority: 102,
-      template: {
-        format: 'حين {event} {body}',
-        tokens: [
-          { type: 'literal', value: 'حين', alternatives: ['حينما'] },
-          { type: 'role', role: 'event' },
-        ],
-      },
-      extraction: {
-        event: { position: 1 },
-      },
-    },
-    {
-      id: 'event-ar-standard',
-      language: 'ar',
-      command: 'on',
-      priority: 100,
-      template: {
-        format: 'عند {event} {body}',
-        tokens: [
-          { type: 'literal', value: 'عند', alternatives: ['على', 'لدى'] },
-          { type: 'role', role: 'event' },
-        ],
-      },
-      extraction: {
-        event: { position: 1 },
-      },
-    },
-    {
-      id: 'event-ar-source',
-      language: 'ar',
-      command: 'on',
-      priority: 110,
-      template: {
-        format: 'عند {event} من {source} {body}',
-        tokens: [
-          { type: 'literal', value: 'عند' },
-          { type: 'role', role: 'event' },
-          { type: 'literal', value: 'من' },
-          { type: 'role', role: 'source' },
-        ],
-      },
-      extraction: {
-        event: { position: 1 },
-        source: { marker: 'من' },
-      },
-    },
-    {
-      id: 'event-ar-conditional',
-      language: 'ar',
-      command: 'on',
-      priority: 95,
-      template: {
-        format: 'إذا {event} {body}',
-        tokens: [
-          { type: 'literal', value: 'إذا', alternatives: ['اذا', 'لو'] },
-          { type: 'role', role: 'event' },
-        ],
-      },
-      extraction: {
-        event: { position: 1 },
-      },
-    },
-    {
-      id: 'event-ar-selector-first',
-      language: 'ar',
-      command: 'on',
-      priority: 92, // Lower than standard patterns (95-115)
-      template: {
-        format: '{source} على {event} {body}',
-        tokens: [
-          { type: 'role', role: 'source', expectedTypes: ['selector'] },
-          { type: 'literal', value: 'على' },
-          { type: 'role', role: 'event' },
-        ],
-      },
-      extraction: {
-        source: { position: 0 },
-        event: { position: 2 },
-      },
-    },
-  ];
+  return [];
 }

package/src/patterns/event-handler/he.ts

@@ -0,0 +1,15 @@
+/**
+ * Hebrew Event Handler Patterns
+ *
+ * Strategy: Return empty array to rely on auto-generated patterns from profile.
+ * Hebrew uses SVO word order with preposition-based event markers (ב/כש/עם).
+ */
+
+import type { LanguagePattern } from '../../types';
+
+/**
+ * Get Hebrew event handler patterns.
+ */
+export function getEventHandlerPatternsHe(): LanguagePattern[] {
+  return [];
+}

package/src/patterns/event-handler/index.ts

@@ -14,6 +14,7 @@ import { getEventHandlerPatternsDe } from './de';
 import { getEventHandlerPatternsEn } from './en';
 import { getEventHandlerPatternsEs } from './es';
 import { getEventHandlerPatternsFr } from './fr';
+import { getEventHandlerPatternsHe } from './he';
 import { getEventHandlerPatternsHi } from './hi';
 import { getEventHandlerPatternsId } from './id';
 import { getEventHandlerPatternsIt } from './it';
@@ -49,6 +50,8 @@ export function getEventHandlerPatternsForLanguage(language: string): LanguagePa
       return getEventHandlerPatternsEs();
     case 'fr':
       return getEventHandlerPatternsFr();
+    case 'he':
+      return getEventHandlerPatternsHe();
     case 'hi':
       return getEventHandlerPatternsHi();
     case 'id':
@@ -95,6 +98,7 @@ export { getEventHandlerPatternsDe } from './de';
 export { getEventHandlerPatternsEn } from './en';
 export { getEventHandlerPatternsEs } from './es';
 export { getEventHandlerPatternsFr } from './fr';
+export { getEventHandlerPatternsHe } from './he';
 export { getEventHandlerPatternsHi } from './hi';
 export { getEventHandlerPatternsId } from './id';
 export { getEventHandlerPatternsIt } from './it';
@@ -116,4 +120,4 @@ export { getEventHandlerPatternsZh } from './zh';
 /**
  * Languages that have hand-crafted event-handler patterns.
  */
-export const eventhandlerPatternLanguages = ['ar', 'bn', 'de', 'en', 'es', 'fr', 'hi', 'id', 'it', 'ja', 'ko', 'ms', 'pl', 'pt', 'qu', 'ru', 'sw', 'th', 'tl', 'tr', 'uk', 'vi', 'zh'];
+export const eventhandlerPatternLanguages = ['ar', 'bn', 'de', 'en', 'es', 'fr', 'he', 'hi', 'id', 'it', 'ja', 'ko', 'ms', 'pl', 'pt', 'qu', 'ru', 'sw', 'th', 'tl', 'tr', 'uk', 'vi', 'zh'];