@lokascript/semantic 1.0.0

package/src/tokenizers/morphology/korean-normalizer.ts

@@ -0,0 +1,428 @@
+/**
+ * Korean Morphological Normalizer
+ *
+ * Reduces Korean verb conjugations to their stem forms.
+ * Korean verbs conjugate by modifying their endings:
+ *
+ * Base: 토글 (togeul) - "toggle" (loanword)
+ * 다 ending: 토글하다 (togeul-hada) - "to toggle" (dictionary form)
+ * 요 ending: 토글해요 (togeul-haeyo) - polite present
+ * 니다 ending: 토글합니다 (togeul-hamnida) - formal present
+ * 세요 ending: 토글하세요 (togeul-haseyo) - honorific request
+ * 았/었 past: 토글했어 (togeul-haesseo) - informal past
+ *
+ * Korean also has vowel harmony affecting suffix forms.
+ *
+ * This normalizer strips these suffixes to find the stem,
+ * which can then be matched against keyword dictionaries.
+ */
+
+import type {
+  MorphologicalNormalizer,
+  NormalizationResult,
+  SuffixRule,
+  ConjugationType,
+} from './types';
+import { noChange, normalized } from './types';
+
+/**
+ * Check if a character is a Korean syllable block (Hangul).
+ * Korean syllables are in the range U+AC00 to U+D7A3.
+ */
+function isHangul(char: string): boolean {
+  const code = char.charCodeAt(0);
+  return code >= 0xac00 && code <= 0xd7a3;
+}
+
+/**
+ * Check if a word contains Korean characters.
+ */
+function containsKorean(word: string): boolean {
+  for (const char of word) {
+    if (isHangul(char)) return true;
+  }
+  return false;
+}
+
+/**
+ * Suffix rules for Korean verb conjugation.
+ * Ordered by length (longest first) to ensure greedy matching.
+ */
+const KOREAN_SUFFIX_RULES: readonly SuffixRule[] = [
+  // Honorific conditional/temporal forms (-시- infix)
+  // These are critical for polite/formal Korean
+  { pattern: '하시니까', confidence: 0.85, conjugationType: 'honorific-causal', minStemLength: 1 },
+  { pattern: '하실때', confidence: 0.88, conjugationType: 'honorific-temporal', minStemLength: 1 },
+  { pattern: '하실 때', confidence: 0.88, conjugationType: 'honorific-temporal', minStemLength: 1 },
+  {
+    pattern: '하시면',
+    confidence: 0.88,
+    conjugationType: 'honorific-conditional',
+    minStemLength: 1,
+  },
+  {
+    pattern: '으시면',
+    confidence: 0.85,
+    conjugationType: 'honorific-conditional',
+    minStemLength: 2,
+  },
+  { pattern: '시면', confidence: 0.82, conjugationType: 'honorific-conditional', minStemLength: 2 },
+
+  // Sequential/temporal forms - "after doing", "before doing", "as soon as"
+  { pattern: '하고나서', confidence: 0.85, conjugationType: 'sequential-after', minStemLength: 1 },
+  { pattern: '하고 나서', confidence: 0.85, conjugationType: 'sequential-after', minStemLength: 1 },
+  { pattern: '하고서', confidence: 0.85, conjugationType: 'sequential-after', minStemLength: 1 },
+  { pattern: '고나서', confidence: 0.82, conjugationType: 'sequential-after', minStemLength: 2 },
+  { pattern: '고 나서', confidence: 0.82, conjugationType: 'sequential-after', minStemLength: 2 },
+  { pattern: '고서', confidence: 0.82, conjugationType: 'sequential-after', minStemLength: 2 },
+  { pattern: '하기전에', confidence: 0.85, conjugationType: 'sequential-before', minStemLength: 1 },
+  {
+    pattern: '하기 전에',
+    confidence: 0.85,
+    conjugationType: 'sequential-before',
+    minStemLength: 1,
+  },
+  { pattern: '기전에', confidence: 0.82, conjugationType: 'sequential-before', minStemLength: 2 },
+  { pattern: '기 전에', confidence: 0.82, conjugationType: 'sequential-before', minStemLength: 2 },
+  { pattern: '하자마자', confidence: 0.88, conjugationType: 'immediate', minStemLength: 1 },
+  { pattern: '자마자', confidence: 0.85, conjugationType: 'immediate', minStemLength: 2 },
+
+  // Obligation forms - "must do", "should do"
+  { pattern: '해야해요', confidence: 0.85, conjugationType: 'obligation', minStemLength: 1 },
+  { pattern: '해야해', confidence: 0.85, conjugationType: 'obligation', minStemLength: 1 },
+  { pattern: '해야하다', confidence: 0.85, conjugationType: 'obligation', minStemLength: 1 },
+  { pattern: '어야해요', confidence: 0.82, conjugationType: 'obligation', minStemLength: 2 },
+  { pattern: '어야해', confidence: 0.82, conjugationType: 'obligation', minStemLength: 2 },
+  { pattern: '아야해요', confidence: 0.82, conjugationType: 'obligation', minStemLength: 2 },
+  { pattern: '아야해', confidence: 0.82, conjugationType: 'obligation', minStemLength: 2 },
+
+  // Conditional forms - most natural for event handlers (longest first)
+  // These are critical for native Korean idioms like "클릭하면 증가"
+  { pattern: '하니까', confidence: 0.85, conjugationType: 'causal-nikka', minStemLength: 1 },
+  { pattern: '할때', confidence: 0.88, conjugationType: 'temporal-ttae', minStemLength: 1 },
+  { pattern: '할 때', confidence: 0.88, conjugationType: 'temporal-ttae', minStemLength: 1 },
+  { pattern: '을때', confidence: 0.85, conjugationType: 'temporal-ttae', minStemLength: 2 },
+  { pattern: '을 때', confidence: 0.85, conjugationType: 'temporal-ttae', minStemLength: 2 },
+  { pattern: '하면', confidence: 0.88, conjugationType: 'conditional-myeon', minStemLength: 1 },
+  { pattern: '으면', confidence: 0.85, conjugationType: 'conditional-myeon', minStemLength: 2 },
+  { pattern: '니까', confidence: 0.82, conjugationType: 'causal-nikka', minStemLength: 2 },
+  { pattern: '면', confidence: 0.8, conjugationType: 'conditional-myeon', minStemLength: 2 },
+
+  // Formal polite forms (longest first)
+  { pattern: '하였습니다', confidence: 0.85, conjugationType: 'past', minStemLength: 1 },
+  { pattern: '했습니다', confidence: 0.85, conjugationType: 'past', minStemLength: 1 },
+  { pattern: '합니다', confidence: 0.85, conjugationType: 'polite', minStemLength: 1 },
+  { pattern: '습니다', confidence: 0.82, conjugationType: 'polite', minStemLength: 2 },
+  { pattern: '됩니다', confidence: 0.82, conjugationType: 'polite', minStemLength: 1 },
+  { pattern: 'ㅂ니다', confidence: 0.82, conjugationType: 'polite', minStemLength: 2 },
+
+  // Honorific request forms
+  { pattern: '하세요', confidence: 0.85, conjugationType: 'honorific', minStemLength: 1 },
+  { pattern: '하십시오', confidence: 0.85, conjugationType: 'honorific', minStemLength: 1 },
+  { pattern: '세요', confidence: 0.82, conjugationType: 'honorific', minStemLength: 2 },
+  { pattern: '십시오', confidence: 0.82, conjugationType: 'honorific', minStemLength: 2 },
+
+  // Informal polite (요) forms
+  { pattern: '하고있어요', confidence: 0.82, conjugationType: 'progressive', minStemLength: 1 },
+  { pattern: '하고있어', confidence: 0.82, conjugationType: 'progressive', minStemLength: 1 },
+  { pattern: '했어요', confidence: 0.85, conjugationType: 'past', minStemLength: 1 },
+  { pattern: '해요', confidence: 0.85, conjugationType: 'polite', minStemLength: 1 },
+  { pattern: '어요', confidence: 0.82, conjugationType: 'polite', minStemLength: 2 },
+  { pattern: '아요', confidence: 0.82, conjugationType: 'polite', minStemLength: 2 },
+
+  // Informal (반말) forms
+  { pattern: '했어', confidence: 0.85, conjugationType: 'past', minStemLength: 1 },
+  { pattern: '해', confidence: 0.8, conjugationType: 'present', minStemLength: 1 },
+  { pattern: '었어', confidence: 0.82, conjugationType: 'past', minStemLength: 2 },
+  { pattern: '았어', confidence: 0.82, conjugationType: 'past', minStemLength: 2 },
+
+  // Progressive forms
+  { pattern: '하고있다', confidence: 0.82, conjugationType: 'progressive', minStemLength: 1 },
+  { pattern: '고있다', confidence: 0.8, conjugationType: 'progressive', minStemLength: 2 },
+  { pattern: '고있어', confidence: 0.8, conjugationType: 'progressive', minStemLength: 2 },
+
+  // Dictionary/infinitive form (하다 verbs)
+  { pattern: '하다', confidence: 0.88, conjugationType: 'dictionary', minStemLength: 1 },
+
+  // Negative forms
+  { pattern: '하지않다', confidence: 0.82, conjugationType: 'negative', minStemLength: 1 },
+  { pattern: '안하다', confidence: 0.82, conjugationType: 'negative', minStemLength: 1 },
+  { pattern: '지않다', confidence: 0.8, conjugationType: 'negative', minStemLength: 2 },
+
+  // Imperative forms
+  { pattern: '해라', confidence: 0.82, conjugationType: 'imperative', minStemLength: 1 },
+  { pattern: '하라', confidence: 0.82, conjugationType: 'imperative', minStemLength: 1 },
+
+  // Generic verb endings (lower confidence)
+  { pattern: '다', confidence: 0.75, conjugationType: 'dictionary', minStemLength: 2 },
+];
+
+/**
+ * 하다 verb pattern - very common pattern in Korean.
+ * Noun + 하다 forms a verb.
+ * e.g., 토글 + 하다 = 토글하다 (to toggle)
+ */
+const HADA_PATTERNS: readonly {
+  pattern: string;
+  confidence: number;
+  conjugationType: ConjugationType;
+}[] = [
+  // Honorific forms (-시- infix) - polite/formal Korean
+  // 클릭하시면 → 클릭 (if you click - honorific)
+  { pattern: '하시니까', confidence: 0.88, conjugationType: 'honorific-causal' },
+  { pattern: '하실때', confidence: 0.88, conjugationType: 'honorific-temporal' },
+  { pattern: '하실 때', confidence: 0.88, conjugationType: 'honorific-temporal' },
+  { pattern: '하시면', confidence: 0.88, conjugationType: 'honorific-conditional' },
+  { pattern: '하셨어요', confidence: 0.85, conjugationType: 'honorific-past' },
+  { pattern: '하셨어', confidence: 0.85, conjugationType: 'honorific-past' },
+  { pattern: '하십니다', confidence: 0.85, conjugationType: 'honorific-polite' },
+
+  // Sequential/temporal forms - "after doing", "before doing", "as soon as"
+  { pattern: '하고나서', confidence: 0.88, conjugationType: 'sequential-after' },
+  { pattern: '하고 나서', confidence: 0.88, conjugationType: 'sequential-after' },
+  { pattern: '하고서', confidence: 0.88, conjugationType: 'sequential-after' },
+  { pattern: '하기전에', confidence: 0.88, conjugationType: 'sequential-before' },
+  { pattern: '하기 전에', confidence: 0.88, conjugationType: 'sequential-before' },
+  { pattern: '하자마자', confidence: 0.88, conjugationType: 'immediate' },
+
+  // Obligation forms - "must do", "should do"
+  { pattern: '해야해요', confidence: 0.88, conjugationType: 'obligation' },
+  { pattern: '해야해', confidence: 0.88, conjugationType: 'obligation' },
+  { pattern: '해야하다', confidence: 0.88, conjugationType: 'obligation' },
+
+  // Conditional forms - most natural for event handlers (highest priority)
+  // 클릭하면 → 클릭 (if clicked)
+  { pattern: '하니까', confidence: 0.88, conjugationType: 'causal-nikka' },
+  { pattern: '할때', confidence: 0.88, conjugationType: 'temporal-ttae' },
+  { pattern: '할 때', confidence: 0.88, conjugationType: 'temporal-ttae' },
+  { pattern: '하면', confidence: 0.88, conjugationType: 'conditional-myeon' },
+
+  // Formal
+  { pattern: '하였습니다', confidence: 0.85, conjugationType: 'past' },
+  { pattern: '했습니다', confidence: 0.85, conjugationType: 'past' },
+  { pattern: '합니다', confidence: 0.85, conjugationType: 'polite' },
+  { pattern: '하십시오', confidence: 0.85, conjugationType: 'honorific' },
+  { pattern: '하세요', confidence: 0.85, conjugationType: 'honorific' },
+  // Informal polite
+  { pattern: '했어요', confidence: 0.85, conjugationType: 'past' },
+  { pattern: '해요', confidence: 0.85, conjugationType: 'polite' },
+  // Informal
+  { pattern: '했어', confidence: 0.85, conjugationType: 'past' },
+  { pattern: '해', confidence: 0.8, conjugationType: 'present' },
+  // Progressive
+  { pattern: '하고있어요', confidence: 0.82, conjugationType: 'progressive' },
+  { pattern: '하고있어', confidence: 0.82, conjugationType: 'progressive' },
+  { pattern: '하고있다', confidence: 0.82, conjugationType: 'progressive' },
+  // Connective forms (해서 = because/so, 하고 = and)
+  { pattern: '해서', confidence: 0.82, conjugationType: 'connective' },
+  { pattern: '하고', confidence: 0.8, conjugationType: 'connective' },
+  // Negative
+  { pattern: '하지않아요', confidence: 0.82, conjugationType: 'negative' },
+  { pattern: '하지않다', confidence: 0.82, conjugationType: 'negative' },
+  { pattern: '안해요', confidence: 0.82, conjugationType: 'negative' },
+  { pattern: '안해', confidence: 0.82, conjugationType: 'negative' },
+  // Imperative
+  { pattern: '해라', confidence: 0.82, conjugationType: 'imperative' },
+  { pattern: '하라', confidence: 0.82, conjugationType: 'imperative' },
+  // Dictionary form
+  { pattern: '하다', confidence: 0.88, conjugationType: 'dictionary' },
+];
+
+/**
+ * Korean morphological normalizer.
+ */
+export class KoreanMorphologicalNormalizer implements MorphologicalNormalizer {
+  readonly language = 'ko';
+
+  /**
+   * Check if a word might be a Korean verb that can be normalized.
+   */
+  isNormalizable(word: string): boolean {
+    // Must contain Korean characters
+    if (!containsKorean(word)) return false;
+
+    // Must be at least 2 characters
+    if (word.length < 2) return false;
+
+    return true;
+  }
+
+  /**
+   * Normalize a Korean word to its stem form.
+   */
+  normalize(word: string): NormalizationResult {
+    // Check for compound conjugations first (multi-layer suffixes)
+    const compoundResult = this.normalizeCompound(word);
+    if (compoundResult) return compoundResult;
+
+    // Check for 하다 verb patterns (most common verb type)
+    const hadaResult = this.tryHadaNormalization(word);
+    if (hadaResult) return hadaResult;
+
+    // Try general suffix rules
+    for (const rule of KOREAN_SUFFIX_RULES) {
+      if (word.endsWith(rule.pattern)) {
+        const stem = word.slice(0, -rule.pattern.length);
+
+        // Validate stem length
+        const minLength = rule.minStemLength ?? 2;
+        if (stem.length < minLength) continue;
+
+        const metadata: {
+          removedSuffixes: string[];
+          conjugationType?: typeof rule.conjugationType;
+        } = {
+          removedSuffixes: [rule.pattern],
+        };
+        if (rule.conjugationType) {
+          metadata.conjugationType = rule.conjugationType;
+        }
+        return normalized(stem, rule.confidence, metadata);
+      }
+    }
+
+    // No normalization needed
+    return noChange(word);
+  }
+
+  /**
+   * Try to normalize a 하다 verb.
+   * 하다 verbs are formed by noun + 하다, very common in Korean.
+   */
+  private tryHadaNormalization(word: string): NormalizationResult | null {
+    for (const pattern of HADA_PATTERNS) {
+      if (word.endsWith(pattern.pattern)) {
+        const stem = word.slice(0, -pattern.pattern.length);
+
+        // 하다 verbs need at least one character for the noun part
+        if (stem.length < 1) continue;
+
+        // Return the noun part (without 하다 conjugation)
+        return normalized(stem, pattern.confidence, {
+          removedSuffixes: [pattern.pattern],
+          conjugationType: pattern.conjugationType,
+          originalForm: 'hada-verb',
+        });
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Normalize compound conjugations (multi-layer suffixes).
+   * Korean has complex compound forms that combine multiple grammatical elements.
+   */
+  private normalizeCompound(word: string): NormalizationResult | null {
+    // Compound patterns with sequential/modal forms
+    const compoundPatterns: readonly {
+      pattern: string;
+      suffixes: string[];
+      confidence: number;
+      conjugationType: ConjugationType;
+      minStemLength: number;
+    }[] = [
+      // Sequential past forms (after doing, was)
+      {
+        pattern: '하고나서였어',
+        suffixes: ['하고나서', '였어'],
+        confidence: 0.78,
+        conjugationType: 'sequential-after',
+        minStemLength: 2,
+      },
+      {
+        pattern: '하고나서였다',
+        suffixes: ['하고나서', '였다'],
+        confidence: 0.78,
+        conjugationType: 'sequential-after',
+        minStemLength: 2,
+      },
+      {
+        pattern: '하고나서',
+        suffixes: ['하고', '나서'],
+        confidence: 0.85,
+        conjugationType: 'sequential-after',
+        minStemLength: 2,
+      },
+
+      // Modal necessity past forms (had to do)
+      {
+        pattern: '해야했어',
+        suffixes: ['해야', '했어'],
+        confidence: 0.8,
+        conjugationType: 'obligation',
+        minStemLength: 2,
+      },
+      {
+        pattern: '해야했다',
+        suffixes: ['해야', '했다'],
+        confidence: 0.8,
+        conjugationType: 'obligation',
+        minStemLength: 2,
+      },
+      {
+        pattern: '해야했습니다',
+        suffixes: ['해야', '했습니다'],
+        confidence: 0.8,
+        conjugationType: 'obligation',
+        minStemLength: 2,
+      },
+
+      // Honorific simultaneous forms (while doing, honorific)
+      {
+        pattern: '하시면서',
+        suffixes: ['하시', '면서'],
+        confidence: 0.82,
+        conjugationType: 'connective',
+        minStemLength: 2,
+      },
+      {
+        pattern: '하시며',
+        suffixes: ['하시', '며'],
+        confidence: 0.82,
+        conjugationType: 'connective',
+        minStemLength: 2,
+      },
+
+      // Progressive forms with copula
+      {
+        pattern: '하고있었어',
+        suffixes: ['하고', '있었어'],
+        confidence: 0.8,
+        conjugationType: 'progressive',
+        minStemLength: 2,
+      },
+      {
+        pattern: '하고있었다',
+        suffixes: ['하고', '있었다'],
+        confidence: 0.8,
+        conjugationType: 'progressive',
+        minStemLength: 2,
+      },
+    ];
+
+    for (const {
+      pattern,
+      suffixes,
+      confidence,
+      conjugationType,
+      minStemLength,
+    } of compoundPatterns) {
+      if (word.endsWith(pattern)) {
+        const stem = word.slice(0, -pattern.length);
+
+        // Validate minimum stem length
+        if (stem.length < minStemLength) continue;
+
+        return normalized(stem, confidence, {
+          removedSuffixes: suffixes,
+          conjugationType,
+        });
+      }
+    }
+
+    return null;
+  }
+}
+
+// Export singleton instance
+export const koreanMorphologicalNormalizer = new KoreanMorphologicalNormalizer();

package/src/tokenizers/morphology/polish-normalizer.ts

@@ -0,0 +1,264 @@
+/**
+ * Polish Morphological Normalizer
+ *
+ * Normalizes Polish verb forms to their base/infinitive form.
+ *
+ * Polish verb conjugation is complex with:
+ * - Three main conjugation classes (determined by infinitive ending)
+ * - Person/number agreement (6 forms per tense)
+ * - Aspect pairs (perfective/imperfective)
+ *
+ * For software UI, Polish uses IMPERATIVE form (unlike most languages):
+ * - zapisz (save), otwórz (open), usuń (delete)
+ *
+ * This normalizer focuses on recognizing imperative forms and
+ * mapping them back to their base form for keyword matching.
+ */
+
+export interface NormalizationResult {
+  stem: string;
+  suffix?: string;
+  confidence: number;
+  originalForm?: string;
+}
+
+/**
+ * Polish Morphological Normalizer
+ *
+ * Key patterns:
+ * - Imperative suffixes: -aj, -ij, -uj (2nd person singular)
+ * - Infinitive endings: -ać, -eć, -ić, -yć, -ąć
+ * - Present tense endings: -am, -em, -ę, -asz, -esz, -isz, -ysz
+ */
+export class PolishMorphologicalNormalizer {
+  /**
+   * Normalize a Polish verb to its base/infinitive form
+   */
+  normalize(word: string): NormalizationResult {
+    const lower = word.toLowerCase();
+
+    // Already in infinitive form (-ać, -eć, -ić, -yć, -ąć, -ować)?
+    if (this.isInfinitive(lower)) {
+      return { stem: lower, confidence: 1.0 };
+    }
+
+    // Try imperative normalization
+    const imperativeResult = this.tryImperativeNormalization(lower);
+    if (imperativeResult) return imperativeResult;
+
+    // Try present tense normalization
+    const presentResult = this.tryPresentTenseNormalization(lower);
+    if (presentResult) return presentResult;
+
+    // Try past tense normalization
+    const pastResult = this.tryPastTenseNormalization(lower);
+    if (pastResult) return pastResult;
+
+    // Return as-is if no normalization found
+    return { stem: lower, confidence: 0.5, originalForm: word };
+  }
+
+  /**
+   * Check if word is already in infinitive form
+   */
+  private isInfinitive(word: string): boolean {
+    const infinitiveEndings = ['ać', 'eć', 'ić', 'yć', 'ąć', 'ować', 'iwać', 'ywać'];
+    return infinitiveEndings.some(ending => word.endsWith(ending));
+  }
+
+  /**
+   * Try to normalize imperative form to infinitive
+   *
+   * Polish imperative (2nd person singular) patterns:
+   * - pisać → pisz (write)
+   * - czytać → czytaj (read)
+   * - robić → rób (do)
+   * - mówić → mów (speak)
+   * - uczyć → ucz (teach)
+   */
+  private tryImperativeNormalization(word: string): NormalizationResult | null {
+    // Common imperative forms used in Polish software UI
+    const imperativeToInfinitive: Map<string, string> = new Map([
+      // Core commands
+      ['przełącz', 'przełączać'],
+      ['przelacz', 'przelaczac'],
+      ['dodaj', 'dodawać'],
+      ['usuń', 'usuwać'],
+      ['usun', 'usuwac'],
+      ['umieść', 'umieszczać'],
+      ['umiesc', 'umieszczac'],
+      ['wstaw', 'wstawiać'],
+      ['ustaw', 'ustawiać'],
+      ['pobierz', 'pobierać'],
+      ['weź', 'brać'],
+      ['wez', 'brac'],
+      ['zwiększ', 'zwiększać'],
+      ['zwieksz', 'zwiekszac'],
+      ['zmniejsz', 'zmniejszać'],
+      ['pokaż', 'pokazywać'],
+      ['pokaz', 'pokazywac'],
+      ['ukryj', 'ukrywać'],
+      ['schowaj', 'schowywać'],
+      ['czekaj', 'czekać'],
+      ['poczekaj', 'poczekać'],
+      ['idź', 'iść'],
+      ['idz', 'isc'],
+      ['przejdź', 'przejść'],
+      ['przejdz', 'przejsc'],
+      ['wywołaj', 'wywoływać'],
+      ['wywolaj', 'wywolywac'],
+      ['wyślij', 'wysyłać'],
+      ['wyslij', 'wysylac'],
+      ['loguj', 'logować'],
+      ['wypisz', 'wypisywać'],
+      ['sklonuj', 'sklonować'],
+      ['kopiuj', 'kopiować'],
+      ['zamień', 'zamieniać'],
+      ['zamien', 'zamieniac'],
+      ['utwórz', 'tworzyć'],
+      ['utworz', 'tworzyc'],
+      ['stwórz', 'stwarzać'],
+      ['stworz', 'stwarzac'],
+      ['skup', 'skupiać'],
+      ['rozmyj', 'rozmywać'],
+      ['nawiguj', 'nawigować'],
+      ['załaduj', 'ładować'],
+      ['zaladuj', 'ladowac'],
+      ['powtórz', 'powtarzać'],
+      ['powtorz', 'powtarzac'],
+      ['kontynuuj', 'kontynuować'],
+      ['zatrzymaj', 'zatrzymywać'],
+      ['przerwij', 'przerywać'],
+      ['rzuć', 'rzucać'],
+      ['rzuc', 'rzucac'],
+      ['zwróć', 'zwracać'],
+      ['zwroc', 'zwracac'],
+      ['inicjuj', 'inicjować'],
+      ['zainstaluj', 'instalować'],
+      ['zmierz', 'mierzyć'],
+    ]);
+
+    if (imperativeToInfinitive.has(word)) {
+      return {
+        stem: imperativeToInfinitive.get(word)!,
+        suffix: 'imperative',
+        confidence: 0.95,
+        originalForm: word,
+      };
+    }
+
+    // Generic imperative pattern: ends in consonant or -j
+    // Try to reconstruct infinitive
+
+    // Pattern: -aj → -ać (czytaj → czytać)
+    if (word.endsWith('aj')) {
+      const stem = word.slice(0, -2) + 'ać';
+      return { stem, suffix: 'aj', confidence: 0.8, originalForm: word };
+    }
+
+    // Pattern: -uj → -ować (kopiuj → kopiować)
+    if (word.endsWith('uj')) {
+      const stem = word.slice(0, -2) + 'ować';
+      return { stem, suffix: 'uj', confidence: 0.8, originalForm: word };
+    }
+
+    // Pattern: -ij → -ić (rób → robić - irregular)
+    if (word.endsWith('ij')) {
+      const stem = word.slice(0, -2) + 'ić';
+      return { stem, suffix: 'ij', confidence: 0.75, originalForm: word };
+    }
+
+    return null;
+  }
+
+  /**
+   * Try to normalize present tense form to infinitive
+   */
+  private tryPresentTenseNormalization(word: string): NormalizationResult | null {
+    // Pattern: -am → -ać (czytam → czytać)
+    if (word.endsWith('am')) {
+      const stem = word.slice(0, -2) + 'ać';
+      return { stem, suffix: 'am', confidence: 0.8, originalForm: word };
+    }
+
+    // Pattern: -em → -eć (rozumiem → rozumieć)
+    if (word.endsWith('em') && word.length > 3) {
+      const stem = word.slice(0, -2) + 'eć';
+      return { stem, suffix: 'em', confidence: 0.75, originalForm: word };
+    }
+
+    // Pattern: -ę → -ać/-eć (piszę → pisać)
+    if (word.endsWith('ę')) {
+      const stem = word.slice(0, -1) + 'ać';
+      return { stem, suffix: 'ę', confidence: 0.7, originalForm: word };
+    }
+
+    // Pattern: -uję → -ować (pracuję → pracować)
+    if (word.endsWith('uję') || word.endsWith('uje')) {
+      const stem = word.slice(0, -3) + 'ować';
+      return { stem, suffix: 'uję', confidence: 0.85, originalForm: word };
+    }
+
+    return null;
+  }
+
+  /**
+   * Try to normalize past tense form to infinitive
+   */
+  private tryPastTenseNormalization(word: string): NormalizationResult | null {
+    // Pattern: -ałem/-ałam → -ać (czytałem → czytać)
+    if (word.endsWith('ałem') || word.endsWith('ałam')) {
+      const stem = word.slice(0, -4) + 'ać';
+      return { stem, suffix: word.slice(-4), confidence: 0.85, originalForm: word };
+    }
+
+    // Pattern: -ał/-ała → -ać (czytał → czytać)
+    if (word.endsWith('ał') || word.endsWith('ała')) {
+      const suffixLen = word.endsWith('ała') ? 3 : 2;
+      const stem = word.slice(0, -suffixLen) + 'ać';
+      return { stem, suffix: word.slice(-suffixLen), confidence: 0.8, originalForm: word };
+    }
+
+    // Pattern: -iłem/-iłam → -ić (robiłem → robić)
+    if (
+      word.endsWith('iłem') ||
+      word.endsWith('iłam') ||
+      word.endsWith('ilem') ||
+      word.endsWith('ilam')
+    ) {
+      const stem = word.slice(0, -4) + 'ić';
+      return { stem, suffix: word.slice(-4), confidence: 0.85, originalForm: word };
+    }
+
+    // Pattern: -ił/-iła → -ić (robił → robić)
+    if (
+      word.endsWith('ił') ||
+      word.endsWith('iła') ||
+      word.endsWith('il') ||
+      word.endsWith('ila')
+    ) {
+      const suffixLen = word.endsWith('iła') || word.endsWith('ila') ? 3 : 2;
+      const stem = word.slice(0, -suffixLen) + 'ić';
+      return { stem, suffix: word.slice(-suffixLen), confidence: 0.8, originalForm: word };
+    }
+
+    return null;
+  }
+
+  /**
+   * Check if two words are morphologically related
+   */
+  areMorphologicallyRelated(word1: string, word2: string): boolean {
+    const norm1 = this.normalize(word1);
+    const norm2 = this.normalize(word2);
+
+    // Same stem
+    if (norm1.stem === norm2.stem) return true;
+
+    // Check if one is prefix of the other (for aspectual pairs)
+    const stems = [norm1.stem, norm2.stem].sort((a, b) => a.length - b.length);
+    if (stems[1].endsWith(stems[0].slice(-4))) return true;
+
+    return false;
+  }
+}