@lokascript/framework 2.0.0

package/src/api/create-dsl.ts

@@ -0,0 +1,367 @@
+/**
+ * Main API for creating multilingual DSLs
+ */
+
+import type { SemanticNode, LanguageTokenizer, LanguagePattern } from '../core/types';
+import type { CommandSchema } from '../schema';
+import { PatternMatcher, type PatternMatcherProfile } from '../core/pattern-matching';
+import { generatePattern, type PatternGenLanguageProfile } from '../generation/pattern-generator';
+import { GrammarTransformer, type LanguageProfile as GrammarProfile } from '../grammar';
+import {
+  type Dictionary,
+  type ProfileProvider,
+  type ValueExtractor,
+  InMemoryDictionary,
+  InMemoryProfileProvider,
+} from '../interfaces';
+
+/**
+ * Language configuration for a DSL.
+ */
+export interface LanguageConfig {
+  /** ISO 639-1 language code */
+  readonly code: string;
+  /** English name of the language */
+  readonly name: string;
+  /** Native name of the language */
+  readonly nativeName: string;
+  /** Language tokenizer */
+  readonly tokenizer: LanguageTokenizer;
+  /** Language profile for pattern generation */
+  readonly patternProfile: PatternGenLanguageProfile;
+  /** Language profile for grammar transformation (optional) */
+  readonly grammarProfile?: GrammarProfile;
+}
+
+/**
+ * Code generator function that transforms semantic AST to target code.
+ */
+export interface CodeGenerator {
+  generate(node: SemanticNode): string;
+}
+
+/**
+ * DSL configuration with dependency injection support.
+ */
+export interface DSLConfig {
+  /** DSL name (for debugging/documentation) */
+  readonly name?: string;
+
+  /** Command schemas defining the DSL grammar */
+  readonly schemas: readonly CommandSchema[];
+
+  /** Language configurations */
+  readonly languages: readonly LanguageConfig[];
+
+  // === Dependency Injection (Optional) ===
+
+  /** Dictionary for keyword translation (default: built from language configs) */
+  readonly dictionary?: Dictionary;
+
+  /** Profile provider for grammar transformation (default: built from language configs) */
+  readonly profileProvider?: ProfileProvider;
+
+  /** Value extractors for tokenization (default: generic extractors) */
+  readonly valueExtractors?: ValueExtractor[];
+
+  /** Code generator for compilation (default: none) */
+  readonly codeGenerator?: CodeGenerator;
+
+  // === Options ===
+
+  /** Auto-generate patterns from schemas (default: true) */
+  readonly generatePatterns?: boolean;
+
+  /** Custom patterns to supplement generated ones */
+  readonly customPatterns?: LanguagePattern[];
+}
+
+/**
+ * Validation result.
+ */
+export interface ValidationResult {
+  readonly valid: boolean;
+  readonly node?: SemanticNode;
+  readonly errors?: string[];
+}
+
+/**
+ * Compilation result.
+ */
+export interface CompileResult {
+  readonly ok: boolean;
+  readonly code?: string;
+  readonly errors?: string[];
+  readonly node?: SemanticNode;
+  readonly metadata?: {
+    readonly parser: string;
+    readonly confidence: number;
+  };
+}
+
+/**
+ * Main multilingual DSL interface.
+ */
+export interface MultilingualDSL {
+  // Parsing
+  parse(input: string, language: string): SemanticNode;
+  parseWithConfidence(input: string, language: string): { node: SemanticNode; confidence: number };
+
+  // Validation
+  validate(input: string, language: string): ValidationResult;
+
+  // Compilation
+  compile(input: string, language: string): CompileResult;
+
+  // Translation
+  translate(input: string, fromLanguage: string, toLanguage: string): string;
+
+  // Language support
+  getSupportedLanguages(): string[];
+}
+
+/**
+ * Internal registry for DSL configuration.
+ */
+class DSLRegistry {
+  private patterns = new Map<string, LanguagePattern[]>();
+  private tokenizers = new Map<string, LanguageTokenizer>();
+  private schemas: readonly CommandSchema[];
+
+  constructor(config: DSLConfig) {
+    this.schemas = config.schemas;
+
+    // Register each language
+    for (const lang of config.languages) {
+      this.registerLanguage(lang);
+    }
+  }
+
+  private registerLanguage(lang: LanguageConfig): void {
+    // Register tokenizer
+    this.tokenizers.set(lang.code, lang.tokenizer);
+
+    // Generate patterns for this language
+    const patterns: LanguagePattern[] = [];
+    for (const schema of this.schemas) {
+      const pattern = generatePattern(schema, lang.patternProfile);
+      patterns.push(pattern);
+    }
+
+    this.patterns.set(lang.code, patterns);
+  }
+
+  getPatterns(language: string): LanguagePattern[] {
+    return this.patterns.get(language) || [];
+  }
+
+  getTokenizer(language: string): LanguageTokenizer | undefined {
+    return this.tokenizers.get(language);
+  }
+
+  getSupportedLanguages(): string[] {
+    return Array.from(this.patterns.keys());
+  }
+}
+
+/**
+ * Implementation of MultilingualDSL.
+ */
+class MultilingualDSLImpl implements MultilingualDSL {
+  private registry: DSLRegistry;
+  private matcher: PatternMatcher;
+  private transformer: GrammarTransformer;
+  private codeGenerator?: CodeGenerator;
+
+  constructor(config: DSLConfig, registry: DSLRegistry, transformer: GrammarTransformer) {
+    this.registry = registry;
+    this.matcher = new PatternMatcher();
+    this.transformer = transformer;
+    if (config.codeGenerator) {
+      this.codeGenerator = config.codeGenerator;
+    }
+  }
+
+  parse(input: string, language: string): SemanticNode {
+    const result = this.parseWithConfidence(input, language);
+    return result.node;
+  }
+
+  parseWithConfidence(input: string, language: string): { node: SemanticNode; confidence: number } {
+    // Get tokenizer for language
+    const tokenizer = this.registry.getTokenizer(language);
+    if (!tokenizer) {
+      throw new Error(`No tokenizer registered for language: ${language}`);
+    }
+
+    // Tokenize input
+    const tokens = tokenizer.tokenize(input);
+
+    // Get patterns for language
+    const patterns = this.registry.getPatterns(language);
+
+    // Create profile for matcher
+    const profile: PatternMatcherProfile = {
+      code: language,
+    };
+
+    // Try to match each pattern
+    for (const pattern of patterns) {
+      const match = this.matcher.matchPattern(tokens, pattern, profile);
+      if (match) {
+        // Build semantic node
+        const node: SemanticNode = {
+          kind: 'command',
+          action: pattern.command,
+          roles: match.captured,
+          metadata: {
+            sourceLanguage: language,
+            sourceText: input,
+            patternId: pattern.id,
+            confidence: match.confidence,
+          },
+        };
+
+        return { node, confidence: match.confidence };
+      }
+    }
+
+    throw new Error(`No pattern matched for input: ${input}`);
+  }
+
+  validate(input: string, language: string): ValidationResult {
+    try {
+      const result = this.parseWithConfidence(input, language);
+      return {
+        valid: true,
+        node: result.node,
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        errors: [error instanceof Error ? error.message : String(error)],
+      };
+    }
+  }
+
+  translate(input: string, fromLanguage: string, toLanguage: string): string {
+    // Use injected grammar transformer
+    return this.transformer.transform(input, fromLanguage, toLanguage);
+  }
+
+  compile(input: string, language: string): CompileResult {
+    if (!this.codeGenerator) {
+      return {
+        ok: false,
+        errors: ['No code generator configured for this DSL'],
+      };
+    }
+
+    try {
+      const result = this.parseWithConfidence(input, language);
+      const code = this.codeGenerator.generate(result.node);
+
+      return {
+        ok: true,
+        code,
+        node: result.node,
+        metadata: {
+          parser: 'semantic',
+          confidence: result.confidence,
+        },
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        errors: [error instanceof Error ? error.message : String(error)],
+      };
+    }
+  }
+
+  getSupportedLanguages(): string[] {
+    return this.registry.getSupportedLanguages();
+  }
+}
+
+/**
+ * Create a new multilingual DSL instance.
+ *
+ * @param config - DSL configuration
+ * @returns MultilingualDSL instance
+ *
+ * @example
+ * ```typescript
+ * const myDSL = createMultilingualDSL({
+ *   schemas: [
+ *     defineCommand('select', [
+ *       defineRole('field', 'identifier', true),
+ *       defineRole('source', 'identifier', true),
+ *     ]),
+ *   ],
+ *   languages: [
+ *     {
+ *       code: 'en',
+ *       name: 'English',
+ *       nativeName: 'English',
+ *       tokenizer: englishTokenizer,
+ *       patternProfile: englishProfile,
+ *     },
+ *   ],
+ *   codeGenerator: {
+ *     generate: (node) => generateSQL(node),
+ *   },
+ * });
+ *
+ * const result = myDSL.compile('select name from users', 'en');
+ * ```
+ */
+/**
+ * Create default dictionary from language configurations.
+ */
+function createDefaultDictionary(config: DSLConfig): Dictionary {
+  const translations: Record<string, Record<string, string>> = {};
+
+  for (const lang of config.languages) {
+    // Convert keyword objects to simple string mappings
+    const keywords: Record<string, string> = {};
+    for (const [canonical, keywordDef] of Object.entries(lang.patternProfile.keywords)) {
+      keywords[canonical] = keywordDef.primary;
+    }
+    translations[lang.code] = keywords;
+  }
+
+  return new InMemoryDictionary(translations);
+}
+
+/**
+ * Create default profile provider from language configurations.
+ */
+function createDefaultProfileProvider(config: DSLConfig): ProfileProvider {
+  const profiles: Record<string, GrammarProfile> = {};
+
+  for (const lang of config.languages) {
+    if (lang.grammarProfile) {
+      profiles[lang.code] = lang.grammarProfile;
+    }
+  }
+
+  return new InMemoryProfileProvider(profiles);
+}
+
+export function createMultilingualDSL(config: DSLConfig): MultilingualDSL {
+  // Create or use provided dictionary
+  const dictionary = config.dictionary ?? createDefaultDictionary(config);
+
+  // Create or use provided profile provider
+  const profileProvider = config.profileProvider ?? createDefaultProfileProvider(config);
+
+  // Create grammar transformer with injected dependencies
+  const transformer = new GrammarTransformer({
+    dictionary,
+    profileProvider,
+  });
+
+  // Create registry and implementation
+  const registry = new DSLRegistry(config);
+  return new MultilingualDSLImpl(config, registry, transformer);
+}

package/src/api/dispatcher.test.ts

@@ -0,0 +1,336 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { CrossDomainDispatcher } from './dispatcher';
+import { DomainRegistry } from './domain-registry';
+import type { DomainDescriptor } from './domain-registry';
+import type { MultilingualDSL } from './create-dsl';
+import type { SemanticNode } from '../core/types';
+
+// =============================================================================
+// Test Helpers
+// =============================================================================
+
+/**
+ * Create a mock DSL that parses input starting with a given keyword.
+ * Confidence is configurable. Throws on non-matching input.
+ */
+function createMockDSL(keyword: string, confidence = 0.9): MultilingualDSL {
+  return {
+    parse(input: string, language: string): SemanticNode {
+      const lower = input.toLowerCase().trim();
+      if (!lower.startsWith(keyword)) {
+        throw new Error(`Input does not start with "${keyword}"`);
+      }
+      return {
+        kind: 'command',
+        action: keyword,
+        roles: new Map([['raw', { type: 'expression' as const, raw: input }]]),
+        metadata: { sourceLanguage: language },
+      };
+    },
+    parseWithConfidence(input: string, language: string) {
+      const node = this.parse(input, language);
+      return { node, confidence };
+    },
+    validate(input: string, language: string) {
+      try {
+        this.parse(input, language);
+        return { valid: true };
+      } catch {
+        return { valid: false, errors: ['Parse failed'] };
+      }
+    },
+    compile(input: string, language: string) {
+      try {
+        const node = this.parse(input, language);
+        return { ok: true, code: `compiled:${keyword}(${input})`, node };
+      } catch {
+        return { ok: false, errors: ['Compile failed'] };
+      }
+    },
+    translate(input: string, _from: string, to: string) {
+      return `[${to}] ${input}`;
+    },
+    getSupportedLanguages() {
+      return ['en', 'ja'];
+    },
+  };
+}
+
+function createDescriptor(name: string, keyword: string, confidence = 0.9): DomainDescriptor {
+  return {
+    name,
+    description: `${name} domain`,
+    languages: ['en', 'ja'],
+    inputLabel: 'input',
+    inputDescription: `${name} input`,
+    getDSL: () => createMockDSL(keyword, confidence),
+  };
+}
+
+// =============================================================================
+// Tests
+// =============================================================================
+
+describe('CrossDomainDispatcher', () => {
+  let registry: DomainRegistry;
+
+  beforeEach(() => {
+    registry = new DomainRegistry();
+  });
+
+  // ---------------------------------------------------------------------------
+  // detect()
+  // ---------------------------------------------------------------------------
+
+  describe('detect', () => {
+    it('returns null when no domains are registered', async () => {
+      const dispatcher = new CrossDomainDispatcher(registry);
+      const result = await dispatcher.detect('anything');
+      expect(result).toBeNull();
+    });
+
+    it('detects the correct domain for matching input', async () => {
+      registry.register(createDescriptor('sql', 'select'));
+      const dispatcher = new CrossDomainDispatcher(registry);
+
+      const result = await dispatcher.detect('select name from users');
+      expect(result).not.toBeNull();
+      expect(result!.domain).toBe('sql');
+      expect(result!.node.action).toBe('select');
+      expect(result!.confidence).toBe(0.9);
+    });
+
+    it('returns null when no domain matches', async () => {
+      registry.register(createDescriptor('sql', 'select'));
+      const dispatcher = new CrossDomainDispatcher(registry);
+
+      const result = await dispatcher.detect('toggle .active');
+      expect(result).toBeNull();
+    });
+
+    it('picks the highest confidence when multiple domains match', async () => {
+      // Both domains accept "select" but with different confidence
+      registry.register(createDescriptor('sql', 'select', 0.95));
+      registry.register(createDescriptor('query', 'select', 0.7));
+      const dispatcher = new CrossDomainDispatcher(registry);
+
+      const result = await dispatcher.detect('select name from users');
+      expect(result).not.toBeNull();
+      expect(result!.domain).toBe('sql');
+      expect(result!.confidence).toBe(0.95);
+    });
+
+    it('breaks confidence ties using priority order', async () => {
+      registry.register(createDescriptor('alpha', 'select', 0.9));
+      registry.register(createDescriptor('beta', 'select', 0.9));
+      const dispatcher = new CrossDomainDispatcher(registry, {
+        priority: ['beta', 'alpha'],
+      });
+
+      const result = await dispatcher.detect('select name from users');
+      expect(result).not.toBeNull();
+      expect(result!.domain).toBe('beta');
+    });
+
+    it('respects minConfidence threshold', async () => {
+      registry.register(createDescriptor('sql', 'select', 0.4));
+      const dispatcher = new CrossDomainDispatcher(registry, {
+        minConfidence: 0.5,
+      });
+
+      const result = await dispatcher.detect('select name from users');
+      expect(result).toBeNull();
+    });
+
+    it('uses default minConfidence of 0.5', async () => {
+      registry.register(createDescriptor('sql', 'select', 0.5));
+      const dispatcher = new CrossDomainDispatcher(registry);
+
+      const result = await dispatcher.detect('select name from users');
+      expect(result).not.toBeNull();
+    });
+
+    it('handles domains that throw on parse', async () => {
+      registry.register(createDescriptor('sql', 'select'));
+      registry.register(createDescriptor('bdd', 'given'));
+      const dispatcher = new CrossDomainDispatcher(registry);
+
+      // "given" input — sql will throw, bdd will match
+      const result = await dispatcher.detect('given page http://example.com');
+      expect(result).not.toBeNull();
+      expect(result!.domain).toBe('bdd');
+    });
+
+    it('uses default language "en"', async () => {
+      registry.register(createDescriptor('sql', 'select'));
+      const dispatcher = new CrossDomainDispatcher(registry);
+
+      const result = await dispatcher.detect('select name');
+      expect(result!.node.metadata?.sourceLanguage).toBe('en');
+    });
+
+    it('passes language parameter through', async () => {
+      registry.register(createDescriptor('sql', 'select'));
+      const dispatcher = new CrossDomainDispatcher(registry);
+
+      const result = await dispatcher.detect('select name', 'ja');
+      expect(result!.node.metadata?.sourceLanguage).toBe('ja');
+    });
+  });
+
+  // ---------------------------------------------------------------------------
+  // parseComposite()
+  // ---------------------------------------------------------------------------
+
+  describe('parseComposite', () => {
+    it('parses multi-line input across domains', async () => {
+      registry.register(createDescriptor('sql', 'select'));
+      registry.register(createDescriptor('bdd', 'given'));
+      const dispatcher = new CrossDomainDispatcher(registry);
+
+      const result = await dispatcher.parseComposite(
+        'select name from users\ngiven page http://example.com'
+      );
+
+      expect(result.statements).toHaveLength(2);
+      expect(result.errors).toHaveLength(0);
+      expect(result.statements[0].domain).toBe('sql');
+      expect(result.statements[0].line).toBe(1);
+      expect(result.statements[1].domain).toBe('bdd');
+      expect(result.statements[1].line).toBe(2);
+    });
+
+    it('skips empty lines', async () => {
+      registry.register(createDescriptor('sql', 'select'));
+      const dispatcher = new CrossDomainDispatcher(registry);
+
+      const result = await dispatcher.parseComposite('\n\nselect name\n\n');
+      expect(result.statements).toHaveLength(1);
+      expect(result.statements[0].line).toBe(3);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('skips comment lines (// and -- and #)', async () => {
+      registry.register(createDescriptor('sql', 'select'));
+      const dispatcher = new CrossDomainDispatcher(registry);
+
+      const result = await dispatcher.parseComposite(
+        '// this is a comment\n-- another comment\n# hash comment\nselect name'
+      );
+      expect(result.statements).toHaveLength(1);
+      expect(result.statements[0].line).toBe(4);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('collects unrecognized lines as errors', async () => {
+      registry.register(createDescriptor('sql', 'select'));
+      const dispatcher = new CrossDomainDispatcher(registry);
+
+      const result = await dispatcher.parseComposite('select name\nunknown command\nselect id');
+      expect(result.statements).toHaveLength(2);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].line).toBe(2);
+      expect(result.errors[0].input).toBe('unknown command');
+      expect(result.errors[0].message).toBe('No domain matched this input');
+    });
+
+    it('handles fully empty input', async () => {
+      const dispatcher = new CrossDomainDispatcher(registry);
+      const result = await dispatcher.parseComposite('');
+      expect(result.statements).toHaveLength(0);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('trims line whitespace before parsing', async () => {
+      registry.register(createDescriptor('sql', 'select'));
+      const dispatcher = new CrossDomainDispatcher(registry);
+
+      const result = await dispatcher.parseComposite('  select name  ');
+      expect(result.statements).toHaveLength(1);
+      expect(result.statements[0].input).toBe('select name');
+    });
+  });
+
+  // ---------------------------------------------------------------------------
+  // compile()
+  // ---------------------------------------------------------------------------
+
+  describe('compile', () => {
+    it('compiles using auto-detected domain', async () => {
+      registry.register(createDescriptor('sql', 'select'));
+      const dispatcher = new CrossDomainDispatcher(registry);
+
+      const result = await dispatcher.compile('select name from users');
+      expect(result).not.toBeNull();
+      expect(result!.ok).toBe(true);
+      expect(result!.domain).toBe('sql');
+      expect(result!.code).toBe('compiled:select(select name from users)');
+    });
+
+    it('returns null when no domain matches', async () => {
+      registry.register(createDescriptor('sql', 'select'));
+      const dispatcher = new CrossDomainDispatcher(registry);
+
+      const result = await dispatcher.compile('unknown input');
+      expect(result).toBeNull();
+    });
+  });
+
+  // ---------------------------------------------------------------------------
+  // validate()
+  // ---------------------------------------------------------------------------
+
+  describe('validate', () => {
+    it('validates using auto-detected domain', async () => {
+      registry.register(createDescriptor('sql', 'select'));
+      const dispatcher = new CrossDomainDispatcher(registry);
+
+      const result = await dispatcher.validate('select name from users');
+      expect(result.valid).toBe(true);
+      expect(result.domain).toBe('sql');
+    });
+
+    it('returns invalid when no domain matches', async () => {
+      registry.register(createDescriptor('sql', 'select'));
+      const dispatcher = new CrossDomainDispatcher(registry);
+
+      const result = await dispatcher.validate('unknown input');
+      expect(result.valid).toBe(false);
+      expect(result.domain).toBeUndefined();
+      expect(result.errors).toContain('No domain matched this input');
+    });
+  });
+
+  // ---------------------------------------------------------------------------
+  // getDSLForDomain (DomainRegistry extension)
+  // ---------------------------------------------------------------------------
+
+  describe('DomainRegistry.getDSLForDomain', () => {
+    it('returns DSL for registered domain', async () => {
+      registry.register(createDescriptor('sql', 'select'));
+      const dsl = await registry.getDSLForDomain('sql');
+      expect(dsl).not.toBeNull();
+      expect(dsl!.getSupportedLanguages()).toContain('en');
+    });
+
+    it('returns null for unregistered domain', async () => {
+      const dsl = await registry.getDSLForDomain('unknown');
+      expect(dsl).toBeNull();
+    });
+
+    it('caches DSL instance across calls', async () => {
+      let callCount = 0;
+      registry.register({
+        ...createDescriptor('sql', 'select'),
+        getDSL: () => {
+          callCount++;
+          return createMockDSL('select');
+        },
+      });
+
+      await registry.getDSLForDomain('sql');
+      await registry.getDSLForDomain('sql');
+      expect(callCount).toBe(1);
+    });
+  });
+});