@lokascript/semantic 1.0.0

package/src/patterns/add/zh.ts

@@ -0,0 +1,71 @@
+/**
+ * Chinese Add Patterns
+ *
+ * Hand-crafted patterns for "add" command.
+ * Chinese uses SVO order: 给 {target} 添加 {patient}
+ */
+
+import type { LanguagePattern } from '../../types';
+
+/**
+ * Get Chinese add patterns.
+ */
+export function getAddPatternsZh(): LanguagePattern[] {
+  return [
+    {
+      id: 'add-zh-full',
+      language: 'zh',
+      command: 'add',
+      priority: 100,
+      template: {
+        format: '给 {destination} 添加 {patient}',
+        tokens: [
+          { type: 'literal', value: '给', alternatives: ['為', '为'] },
+          { type: 'role', role: 'destination' },
+          { type: 'literal', value: '添加', alternatives: ['加', '增加', '加上'] },
+          { type: 'role', role: 'patient' },
+        ],
+      },
+      extraction: {
+        destination: { position: 1 },
+        patient: { position: 3 },
+      },
+    },
+    {
+      id: 'add-zh-simple',
+      language: 'zh',
+      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-zh-ba',
+      language: 'zh',
+      command: 'add',
+      priority: 95,
+      template: {
+        format: '把 {patient} 添加到 {destination}',
+        tokens: [
+          { type: 'literal', value: '把' },
+          { type: 'role', role: 'patient' },
+          { type: 'literal', value: '添加到', alternatives: ['加到', '增加到'] },
+          { type: 'role', role: 'destination' },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+        destination: { marker: '添加到', markerAlternatives: ['加到', '增加到'] },
+      },
+    },
+  ];
+}

package/src/patterns/builders.ts

@@ -0,0 +1,207 @@
+/**
+ * Pattern Builders
+ *
+ * Functions for building and generating patterns for specific languages.
+ * Uses a registry-based approach for maintainability and extensibility.
+ */
+
+import type { LanguagePattern } from '../types';
+
+// Import from subdirectories for tree-shaking
+import { getTogglePatternsForLanguage } from './toggle/index';
+import { getTakePatternsForLanguage } from './take/index';
+import { getPutPatternsForLanguage } from './put/index';
+import { getEventHandlerPatternsForLanguage } from './event-handler/index';
+import { getGrammarTransformedPatternsForLanguage } from './grammar-transformed/index';
+
+// Import multilingual command patterns
+import { getAddPatternsForLanguage } from './add/index';
+import { getRemovePatternsForLanguage } from './remove/index';
+import { getShowPatternsForLanguage } from './show/index';
+import { getHidePatternsForLanguage } from './hide/index';
+import { getSetPatternsForLanguage } from './set/index';
+import { getGetPatternsForLanguage } from './get/index';
+import { getIncrementPatternsForLanguage } from './increment/index';
+import { getDecrementPatternsForLanguage } from './decrement/index';
+
+// Import English-only patterns
+import { getEnglishOnlyPatterns } from './languages/en';
+
+// Import generator directly (not from barrel)
+import { generatePatternsForLanguage } from '../generators/pattern-generator';
+
+// Import registry functions for lazy loading support
+import { getRegisteredLanguages, tryGetProfile } from '../registry';
+
+// =============================================================================
+// Pattern Loader Registry
+// =============================================================================
+
+/**
+ * Type for pattern loader functions.
+ * Each loader returns patterns for a specific command/category for a given language.
+ */
+type PatternLoader = (language: string) => LanguagePattern[];
+
+/**
+ * Registry of all pattern loaders.
+ * This replaces individual push() calls with a unified registry approach.
+ * Order matters: hand-crafted patterns should come before generated patterns.
+ */
+const PATTERN_LOADERS: PatternLoader[] = [
+  // Hand-crafted core patterns
+  getTogglePatternsForLanguage,
+  getTakePatternsForLanguage,
+  getPutPatternsForLanguage,
+  getEventHandlerPatternsForLanguage,
+
+  // Multilingual command patterns
+  getAddPatternsForLanguage,
+  getRemovePatternsForLanguage,
+  getShowPatternsForLanguage,
+  getHidePatternsForLanguage,
+  getSetPatternsForLanguage,
+  getGetPatternsForLanguage,
+  getIncrementPatternsForLanguage,
+  getDecrementPatternsForLanguage,
+
+  // Grammar-transformed patterns (for SOV/VSO grammar output)
+  getGrammarTransformedPatternsForLanguage,
+];
+
+/**
+ * Register a custom pattern loader.
+ * Useful for plugins or extensions that add new command patterns.
+ */
+export function registerPatternLoader(loader: PatternLoader): void {
+  PATTERN_LOADERS.push(loader);
+}
+
+/**
+ * Get the current pattern loaders (for testing/introspection).
+ */
+export function getPatternLoaders(): readonly PatternLoader[] {
+  return PATTERN_LOADERS;
+}
+
+// Lazy cache for generated patterns PER LANGUAGE
+// Using per-language cache instead of global cache to support lazy loading
+// where languages are registered one at a time
+const _generatedPatternsPerLanguage = new Map<string, LanguagePattern[]>();
+
+/**
+ * Get all generated patterns (lazy loaded).
+ * @deprecated Use getGeneratedPatternsForLanguage() for lazy loading support.
+ */
+export function getGeneratedPatterns(): LanguagePattern[] {
+  // For backwards compatibility, generate for all currently registered languages
+  const allPatterns: LanguagePattern[] = [];
+  for (const lang of getRegisteredLanguages()) {
+    allPatterns.push(...getGeneratedPatternsForLanguage(lang));
+  }
+  return allPatterns;
+}
+
+/**
+ * Get generated patterns for a specific language.
+ * This supports lazy loading scenarios where languages are registered one at a time.
+ */
+export function getGeneratedPatternsForLanguage(language: string): LanguagePattern[] {
+  // Check per-language cache first
+  const cached = _generatedPatternsPerLanguage.get(language);
+  if (cached) {
+    return cached;
+  }
+
+  // Get profile from registry
+  const profile = tryGetProfile(language);
+  if (!profile) {
+    return [];
+  }
+
+  // Generate patterns for this language
+  const patterns = generatePatternsForLanguage(profile);
+  _generatedPatternsPerLanguage.set(language, patterns);
+  return patterns;
+}
+
+/**
+ * Clear the generated patterns cache for a language (useful for testing).
+ */
+export function clearGeneratedPatternsCache(language?: string): void {
+  if (language) {
+    _generatedPatternsPerLanguage.delete(language);
+  } else {
+    _generatedPatternsPerLanguage.clear();
+  }
+}
+
+// =============================================================================
+// Lazy Pattern Building
+// =============================================================================
+
+/**
+ * Build patterns for a specific language.
+ * This is the core function for tree-shakeable pattern loading.
+ * Uses the PATTERN_LOADERS registry for maintainability.
+ */
+export function buildPatternsForLanguage(language: string): LanguagePattern[] {
+  // Collect patterns from all registered loaders
+  const patterns = PATTERN_LOADERS.flatMap(loader => loader(language));
+
+  // Add English-only hand-crafted patterns
+  if (language === 'en') {
+    patterns.push(...getEnglishOnlyPatterns());
+  }
+
+  // Add generated patterns for this language (per-language cache supports lazy loading)
+  patterns.push(...getGeneratedPatternsForLanguage(language));
+
+  return patterns;
+}
+
+// Languages with hand-crafted patterns
+const handcraftedLanguages = [
+  'en',
+  'ja',
+  'ar',
+  'es',
+  'ko',
+  'zh',
+  'tr',
+  'pt',
+  'fr',
+  'de',
+  'id',
+  'qu',
+  'sw',
+  'it',
+  'vi',
+  'pl',
+  'ru',
+  'uk',
+  'hi',
+  'bn',
+  'th',
+  'ms',
+  'tl',
+];
+
+/**
+ * Build patterns for all languages.
+ * @deprecated Use getPatternsForLanguage() for tree-shaking.
+ */
+export function buildAllPatterns(): LanguagePattern[] {
+  const all: LanguagePattern[] = [];
+  for (const lang of handcraftedLanguages) {
+    all.push(...buildPatternsForLanguage(lang));
+  }
+  return all;
+}
+
+/**
+ * Get list of all supported languages.
+ */
+export function getHandcraftedLanguages(): readonly string[] {
+  return handcraftedLanguages;
+}

package/src/patterns/decrement/bn.ts

@@ -0,0 +1,70 @@
+/**
+ * Bengali Decrement Patterns
+ *
+ * Patterns for parsing "decrement" command in Bengali.
+ */
+
+import type { LanguagePattern } from '../../types';
+
+export function getDecrementPatternsBn(): LanguagePattern[] {
+  return [
+    // Full pattern: :counter কে হ্রাস করুন
+    {
+      id: 'decrement-bn-full',
+      language: 'bn',
+      command: 'decrement',
+      priority: 100,
+      template: {
+        format: '{patient} কে হ্রাস করুন',
+        tokens: [
+          { type: 'role', role: 'patient' },
+          { type: 'literal', value: 'কে' },
+          { type: 'literal', value: 'হ্রাস', alternatives: ['কমান'] },
+          { type: 'literal', value: 'করুন' },
+        ],
+      },
+      extraction: {
+        patient: { position: 0 },
+      },
+    },
+    // With quantity: :counter কে 5 দিয়ে হ্রাস করুন
+    {
+      id: 'decrement-bn-with-quantity',
+      language: 'bn',
+      command: 'decrement',
+      priority: 95,
+      template: {
+        format: '{patient} কে {quantity} দিয়ে হ্রাস করুন',
+        tokens: [
+          { type: 'role', role: 'patient' },
+          { type: 'literal', value: 'কে' },
+          { type: 'role', role: 'quantity' },
+          { type: 'literal', value: 'দিয়ে' },
+          { type: 'literal', value: 'হ্রাস', alternatives: ['কমান'] },
+          { type: 'literal', value: 'করুন' },
+        ],
+      },
+      extraction: {
+        patient: { position: 0 },
+        quantity: { marker: 'দিয়ে', position: 2 },
+      },
+    },
+    // Simple pattern: হ্রাস :counter
+    {
+      id: 'decrement-bn-simple',
+      language: 'bn',
+      command: 'decrement',
+      priority: 90,
+      template: {
+        format: 'হ্রাস {patient}',
+        tokens: [
+          { type: 'literal', value: 'হ্রাস', alternatives: ['কমান'] },
+          { type: 'role', role: 'patient' },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+      },
+    },
+  ];
+}

package/src/patterns/decrement/de.ts

@@ -0,0 +1,42 @@
+/**
+ * German Decrement Patterns
+ *
+ * Hand-crafted patterns for "decrement" command.
+ * German: verringere zähler
+ */
+
+import type { LanguagePattern } from '../../types';
+
+/**
+ * Get German decrement patterns.
+ */
+export function getDecrementPatternsDe(): LanguagePattern[] {
+  return [
+    {
+      id: 'decrement-de-full',
+      language: 'de',
+      command: 'decrement',
+      priority: 100,
+      template: {
+        format: 'verringere {patient}',
+        tokens: [
+          {
+            type: 'literal',
+            value: 'verringere',
+            alternatives: [
+              'verringern',
+              'dekrementiere',
+              'dekrementieren',
+              'reduziere',
+              'decrement',
+            ],
+          },
+          { type: 'role', role: 'patient', expectedTypes: ['selector', 'reference', 'expression'] },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+      },
+    },
+  ];
+}

package/src/patterns/decrement/hi.ts

@@ -0,0 +1,68 @@
+/**
+ * Hindi Decrement Patterns
+ *
+ * Patterns for parsing "decrement" command in Hindi.
+ */
+
+import type { LanguagePattern } from '../../types';
+
+export function getDecrementPatternsHi(): LanguagePattern[] {
+  return [
+    // Full pattern: :counter को घटाएं
+    {
+      id: 'decrement-hi-full',
+      language: 'hi',
+      command: 'decrement',
+      priority: 100,
+      template: {
+        format: '{patient} को घटाएं',
+        tokens: [
+          { type: 'role', role: 'patient' },
+          { type: 'literal', value: 'को' },
+          { type: 'literal', value: 'घटाएं', alternatives: ['घटा'] },
+        ],
+      },
+      extraction: {
+        patient: { position: 0 },
+      },
+    },
+    // With quantity: :counter को 5 से घटाएं
+    {
+      id: 'decrement-hi-with-quantity',
+      language: 'hi',
+      command: 'decrement',
+      priority: 95,
+      template: {
+        format: '{patient} को {quantity} से घटाएं',
+        tokens: [
+          { type: 'role', role: 'patient' },
+          { type: 'literal', value: 'को' },
+          { type: 'role', role: 'quantity' },
+          { type: 'literal', value: 'से' },
+          { type: 'literal', value: 'घटाएं', alternatives: ['घटा'] },
+        ],
+      },
+      extraction: {
+        patient: { position: 0 },
+        quantity: { marker: 'से', position: 2 },
+      },
+    },
+    // Simple pattern: घटाएं :counter
+    {
+      id: 'decrement-hi-simple',
+      language: 'hi',
+      command: 'decrement',
+      priority: 90,
+      template: {
+        format: 'घटाएं {patient}',
+        tokens: [
+          { type: 'literal', value: 'घटाएं', alternatives: ['घटा'] },
+          { type: 'role', role: 'patient' },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+      },
+    },
+  ];
+}

package/src/patterns/decrement/index.ts

@@ -0,0 +1,79 @@
+/**
+ * Decrement Command Patterns
+ *
+ * Hand-crafted patterns for "decrement" command across languages.
+ *
+ * @generated This file is auto-generated. Do not edit manually.
+ */
+
+import type { LanguagePattern } from '../../types';
+
+import { getDecrementPatternsBn } from './bn';
+import { getDecrementPatternsDe } from './de';
+import { getDecrementPatternsHi } from './hi';
+import { getDecrementPatternsIt } from './it';
+import { getDecrementPatternsMs } from './ms';
+import { getDecrementPatternsPl } from './pl';
+import { getDecrementPatternsRu } from './ru';
+import { getDecrementPatternsTh } from './th';
+import { getDecrementPatternsTl } from './tl';
+import { getDecrementPatternsTr } from './tr';
+import { getDecrementPatternsUk } from './uk';
+import { getDecrementPatternsVi } from './vi';
+import { getDecrementPatternsZh } from './zh';
+
+/**
+ * Get decrement patterns for a specific language.
+ */
+export function getDecrementPatternsForLanguage(language: string): LanguagePattern[] {
+  switch (language) {
+    case 'bn':
+      return getDecrementPatternsBn();
+    case 'de':
+      return getDecrementPatternsDe();
+    case 'hi':
+      return getDecrementPatternsHi();
+    case 'it':
+      return getDecrementPatternsIt();
+    case 'ms':
+      return getDecrementPatternsMs();
+    case 'pl':
+      return getDecrementPatternsPl();
+    case 'ru':
+      return getDecrementPatternsRu();
+    case 'th':
+      return getDecrementPatternsTh();
+    case 'tl':
+      return getDecrementPatternsTl();
+    case 'tr':
+      return getDecrementPatternsTr();
+    case 'uk':
+      return getDecrementPatternsUk();
+    case 'vi':
+      return getDecrementPatternsVi();
+    case 'zh':
+      return getDecrementPatternsZh();
+    default:
+      return [];
+  }
+}
+
+// Re-export language-specific getters for tree-shaking
+export { getDecrementPatternsBn } from './bn';
+export { getDecrementPatternsDe } from './de';
+export { getDecrementPatternsHi } from './hi';
+export { getDecrementPatternsIt } from './it';
+export { getDecrementPatternsMs } from './ms';
+export { getDecrementPatternsPl } from './pl';
+export { getDecrementPatternsRu } from './ru';
+export { getDecrementPatternsTh } from './th';
+export { getDecrementPatternsTl } from './tl';
+export { getDecrementPatternsTr } from './tr';
+export { getDecrementPatternsUk } from './uk';
+export { getDecrementPatternsVi } from './vi';
+export { getDecrementPatternsZh } from './zh';
+
+/**
+ * Languages that have hand-crafted decrement patterns.
+ */
+export const decrementPatternLanguages = ['bn', 'de', 'hi', 'it', 'ms', 'pl', 'ru', 'th', 'tl', 'tr', 'uk', 'vi', 'zh'];

package/src/patterns/decrement/it.ts

@@ -0,0 +1,69 @@
+/**
+ * Italian Decrement Patterns
+ *
+ * Tree-shakeable: Only included when Italian is imported.
+ */
+
+import type { LanguagePattern } from '../../types';
+
+/**
+ * Get Italian decrement patterns.
+ */
+export function getDecrementPatternsIt(): LanguagePattern[] {
+  return [
+    {
+      id: 'decrement-it-full',
+      language: 'it',
+      command: 'decrement',
+      priority: 100,
+      template: {
+        format: 'decrementare {patient} di {quantity}',
+        tokens: [
+          {
+            type: 'literal',
+            value: 'decrementare',
+            alternatives: ['decrementa', 'diminuire', 'decrement'],
+          },
+          { type: 'role', role: 'patient' },
+          {
+            type: 'group',
+            optional: true,
+            tokens: [
+              { type: 'literal', value: 'di', alternatives: ['per'] },
+              { type: 'role', role: 'quantity' },
+            ],
+          },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+        quantity: {
+          marker: 'di',
+          markerAlternatives: ['per'],
+          default: { type: 'literal', value: '1' },
+        },
+      },
+    },
+    {
+      id: 'decrement-it-simple',
+      language: 'it',
+      command: 'decrement',
+      priority: 90,
+      template: {
+        format: 'decrementare {patient}',
+        tokens: [
+          {
+            type: 'literal',
+            value: 'decrementare',
+            alternatives: ['decrementa', 'diminuire', 'decrement'],
+          },
+          { type: 'role', role: 'patient' },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+        quantity: { default: { type: 'literal', value: '1' } },
+      },
+    },
+  ];
+}

package/src/patterns/decrement/ms.ts

@@ -0,0 +1,30 @@
+/**
+ * Malay Decrement Patterns
+ *
+ * Patterns for parsing "decrement" command in Malay.
+ */
+
+import type { LanguagePattern } from '../../types';
+
+export function getDecrementPatternsMs(): LanguagePattern[] {
+  return [
+    // TODO: Add patterns for decrement
+    // Example:
+    // {
+    //   id: 'decrement-ms-simple',
+    //   language: 'ms',
+    //   command: 'decrement',
+    //   priority: 100,
+    //   template: {
+    //     format: 'TODO {patient}',
+    //     tokens: [
+    //       { type: 'literal', value: 'TODO' },
+    //       { type: 'role', role: 'patient' },
+    //     ],
+    //   },
+    //   extraction: {
+    //     patient: { position: 1 },
+    //   },
+    // },
+  ];
+}

package/src/patterns/decrement/pl.ts

@@ -0,0 +1,58 @@
+/**
+ * Polish Decrement Patterns
+ *
+ * Tree-shakeable: Only included when Polish is imported.
+ * Polish uses imperative verb forms for commands.
+ */
+
+import type { LanguagePattern } from '../../types';
+
+/**
+ * Get Polish decrement patterns.
+ */
+export function getDecrementPatternsPl(): LanguagePattern[] {
+  return [
+    {
+      id: 'decrement-pl-full',
+      language: 'pl',
+      command: 'decrement',
+      priority: 100,
+      template: {
+        format: 'zmniejsz {patient} o {quantity}',
+        tokens: [
+          { type: 'literal', value: 'zmniejsz', alternatives: ['obniż', 'obniz'] },
+          { type: 'role', role: 'patient' },
+          {
+            type: 'group',
+            optional: true,
+            tokens: [
+              { type: 'literal', value: 'o' },
+              { type: 'role', role: 'quantity' },
+            ],
+          },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+        quantity: { marker: 'o', default: { type: 'literal', value: 1 } },
+      },
+    },
+    {
+      id: 'decrement-pl-simple',
+      language: 'pl',
+      command: 'decrement',
+      priority: 90,
+      template: {
+        format: 'zmniejsz {patient}',
+        tokens: [
+          { type: 'literal', value: 'zmniejsz', alternatives: ['obniż', 'obniz'] },
+          { type: 'role', role: 'patient' },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+        quantity: { default: { type: 'literal', value: 1 } },
+      },
+    },
+  ];
+}