@baselineos/protocol-core 1.0.0

package/src/lang/lang.ts

@@ -0,0 +1,278 @@
+/**
+ * Baseline Lang -- Core Language Implementation
+ * The Language & Expression Layer of Baseline Stack
+ *
+ * @license Apache-2.0
+ */
+
+import type { BaselineProgram } from '../types/index.js';
+import type { BaselineParser } from '../parser/parser.js';
+import type { BaselineLexicon } from '../lexicon/lexicon.js';
+
+// ─── Result Types ───────────────────────────────────────────────────
+
+export interface ValidationResult {
+  isValid: boolean;
+  errors: string[];
+  warnings: string[];
+  suggestions: string[];
+}
+
+export interface ExecutionResult {
+  success: boolean;
+  outputs: unknown[];
+  metrics: Record<string, unknown>;
+  timestamp: Date;
+}
+
+export interface IntermediateRepresentation {
+  version: string;
+  blocks: BaselineProgram['blocks'];
+  metadata: BaselineProgram['metadata'];
+  optimizations: unknown[];
+}
+
+export interface LanguageStats {
+  totalBlocks: number;
+  blockTypes: Record<string, number>;
+  lexiconSize: number;
+  patternCount: number;
+  templateCount: number;
+  complexity: 'low' | 'medium' | 'high' | 'complex';
+}
+
+// ─── BaselineLang ───────────────────────────────────────────────────
+
+export class BaselineLang {
+  private parser: BaselineParser;
+  private lexicon: BaselineLexicon;
+
+  constructor(parser: BaselineParser, lexicon: BaselineLexicon) {
+    this.parser = parser;
+    this.lexicon = lexicon;
+  }
+
+  async initialize(): Promise<void> {
+    await this.initializeLanguageComponents();
+    await this.initializeDefaultLexicons();
+    await this.initializeLanguagePatterns();
+  }
+
+  /**
+   * Get the lexicon instance
+   */
+  getLexicon(): BaselineLexicon {
+    return this.lexicon;
+  }
+
+  /**
+   * Parse Baseline Language source code
+   */
+  async parseSource(source: string): Promise<BaselineProgram> {
+    try {
+      const program = await this.parser.parse(source);
+      return program;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Parsing failed: ${errorMessage}`);
+    }
+  }
+
+  /**
+   * Compile Baseline Language to Intermediate Representation
+   */
+  async compileToIR(program: BaselineProgram): Promise<IntermediateRepresentation> {
+    try {
+      const ir = await this.compileProgram(program);
+      return ir;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Compilation failed: ${errorMessage}`);
+    }
+  }
+
+  /**
+   * Execute Baseline Language program
+   */
+  async execute(program: BaselineProgram): Promise<ExecutionResult> {
+    try {
+      const ir = await this.compileToIR(program);
+      const result = await this.executeIR(ir);
+      return result;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Execution failed: ${errorMessage}`);
+    }
+  }
+
+  /**
+   * Validate Baseline Language program
+   */
+  async validate(program: BaselineProgram): Promise<ValidationResult> {
+    try {
+      const validation = await this.validateProgram(program);
+      return validation;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Validation failed: ${errorMessage}`);
+    }
+  }
+
+  /**
+   * Generate Baseline Language from template
+   */
+  async generateFromTemplate(
+    template: string,
+    variables: Record<string, unknown>,
+  ): Promise<string> {
+    try {
+      const generated = await this.generateLanguage(template, variables);
+      return generated;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Generation failed: ${errorMessage}`);
+    }
+  }
+
+  /**
+   * Get language statistics and metrics
+   */
+  async getLanguageStats(): Promise<LanguageStats> {
+    try {
+      const stats = await this.calculateLanguageStats();
+      return stats;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Stats calculation failed: ${errorMessage}`);
+    }
+  }
+
+  // ─── Private Implementation ─────────────────────────────────────────
+
+  private async initializeLanguageComponents(): Promise<void> {
+    await this.initializeLexiconSystem();
+    await this.initializeSyntaxSystem();
+    await this.initializeCommandSystem();
+  }
+
+  private async initializeDefaultLexicons(): Promise<void> {
+    await this.lexicon.loadDefaultPacks();
+  }
+
+  private async initializeLanguagePatterns(): Promise<void> {
+    await this.initializePatterns();
+  }
+
+  private async initializeLexiconSystem(): Promise<void> {
+    // Initialize lexicon management system
+  }
+
+  private async initializeSyntaxSystem(): Promise<void> {
+    // Initialize syntax and grammar system
+  }
+
+  private async initializeCommandSystem(): Promise<void> {
+    // Initialize command and operation system
+  }
+
+  private async initializePatterns(): Promise<void> {
+    // Initialize language patterns
+  }
+
+  private async compileProgram(
+    program: BaselineProgram,
+  ): Promise<IntermediateRepresentation> {
+    return {
+      version: '1.0.0',
+      blocks: program.blocks,
+      metadata: program.metadata,
+      optimizations: [],
+    };
+  }
+
+  private async executeIR(_ir: IntermediateRepresentation): Promise<ExecutionResult> {
+    return {
+      success: true,
+      outputs: [],
+      metrics: {},
+      timestamp: new Date(),
+    };
+  }
+
+  private async validateProgram(program: BaselineProgram): Promise<ValidationResult> {
+    const validation: ValidationResult = {
+      isValid: true,
+      errors: [],
+      warnings: [],
+      suggestions: [],
+    };
+
+    if (!program.blocks || program.blocks.length === 0) {
+      validation.isValid = false;
+      validation.errors.push('Program must contain at least one block');
+    }
+
+    if (!program.metadata) {
+      validation.isValid = false;
+      validation.errors.push('Program must have metadata');
+    }
+
+    for (const block of program.blocks) {
+      const blockValidation = await this.validateBlock(block);
+      if (!blockValidation.isValid) {
+        validation.isValid = false;
+        validation.errors.push(...blockValidation.errors);
+      }
+      validation.warnings.push(...blockValidation.warnings);
+      validation.suggestions.push(...blockValidation.suggestions);
+    }
+
+    return validation;
+  }
+
+  private async validateBlock(
+    block: BaselineProgram['blocks'][number],
+  ): Promise<ValidationResult> {
+    const validation: ValidationResult = {
+      isValid: true,
+      errors: [],
+      warnings: [],
+      suggestions: [],
+    };
+
+    if (!block.type) {
+      validation.isValid = false;
+      validation.errors.push('Block must have a type');
+    }
+
+    if (!block.metadata) {
+      validation.isValid = false;
+      validation.errors.push('Block must have metadata');
+    }
+
+    return validation;
+  }
+
+  private async generateLanguage(
+    template: string,
+    variables: Record<string, unknown>,
+  ): Promise<string> {
+    let generated = template;
+    for (const [key, value] of Object.entries(variables)) {
+      const placeholder = `{{${key}}}`;
+      generated = generated.replace(new RegExp(placeholder, 'g'), String(value));
+    }
+    return generated;
+  }
+
+  private async calculateLanguageStats(): Promise<LanguageStats> {
+    return {
+      totalBlocks: 0,
+      blockTypes: {},
+      lexiconSize: 0,
+      patternCount: 0,
+      templateCount: 0,
+      complexity: 'low',
+    };
+  }
+}

package/src/lexicon/lexicon.ts

@@ -0,0 +1,414 @@
+/**
+ * Baseline Language Lexicon Management
+ * Domain-specific vocabulary and template system
+ *
+ * @license Apache-2.0
+ */
+
+// ─── Lexicon Types ──────────────────────────────────────────────────
+
+export interface LexiconDomain {
+  name: string;
+  description: string;
+  vocabulary: string[];
+  patterns: string[];
+  examples: string[];
+}
+
+export interface LexiconTerm {
+  name: string;
+  definition: string;
+  synonyms: string[];
+  antonyms: string[];
+  examples: string[];
+}
+
+export interface LexiconVocabulary {
+  terms: LexiconTerm[];
+  synonyms: unknown[];
+  antonyms: unknown[];
+  definitions: LexiconDefinition[];
+}
+
+export interface LexiconDefinition {
+  meaning: string;
+  context: string;
+  examples: string[];
+}
+
+export interface LexiconTemplate {
+  name: string;
+  description: string;
+  pattern: string;
+  variables: LexiconVariable[];
+  examples: string[];
+}
+
+export interface LexiconVariable {
+  name: string;
+  type: string;
+  description: string;
+  required: boolean;
+  default?: string;
+}
+
+export interface LexiconPattern {
+  name: string;
+  description: string;
+  regex: string;
+  examples: string[];
+  usage: string[];
+}
+
+export interface SearchResult {
+  type: 'term' | 'definition';
+  domain: string;
+  item: LexiconTerm | LexiconDefinition;
+  relevance: number;
+}
+
+export interface LexiconStats {
+  totalDomains: number;
+  totalTerms: number;
+  totalTemplates: number;
+  totalPatterns: number;
+  domains: string[];
+  vocabularySizes: Record<string, number>;
+}
+
+// ─── Lexicon ────────────────────────────────────────────────────────
+
+export class BaselineLexicon {
+  private domains: Map<string, LexiconDomain> = new Map();
+  private vocabulary: Map<string, LexiconVocabulary> = new Map();
+  private templates: Map<string, LexiconTemplate> = new Map();
+  private patterns: Map<string, LexiconPattern> = new Map();
+
+  async initialize(): Promise<void> {
+    await this.initializeDefaultDomains();
+    await this.initializeDefaultVocabulary();
+    await this.initializeDefaultTemplates();
+    await this.initializeDefaultPatterns();
+  }
+
+  /**
+   * Load default lexicon packs
+   */
+  async loadDefaultPacks(): Promise<void> {
+    await this.loadCoreDomainPack();
+    await this.loadAIMLDomainPack();
+    await this.loadBusinessDomainPack();
+  }
+
+  /**
+   * Add a new domain
+   */
+  addDomain(domain: LexiconDomain): void {
+    this.domains.set(domain.name, domain);
+  }
+
+  /**
+   * Get domain by name
+   */
+  getDomain(name: string): LexiconDomain | undefined {
+    return this.domains.get(name);
+  }
+
+  /**
+   * List all domains
+   */
+  listDomains(): LexiconDomain[] {
+    return Array.from(this.domains.values());
+  }
+
+  /**
+   * Add vocabulary set
+   */
+  addVocabulary(domain: string, vocabulary: LexiconVocabulary): void {
+    this.vocabulary.set(domain, vocabulary);
+  }
+
+  /**
+   * Get vocabulary for domain
+   */
+  getVocabulary(domain: string): LexiconVocabulary | undefined {
+    return this.vocabulary.get(domain);
+  }
+
+  /**
+   * Add template
+   */
+  addTemplate(template: LexiconTemplate): void {
+    this.templates.set(template.name, template);
+  }
+
+  /**
+   * Get template by name
+   */
+  getTemplate(name: string): LexiconTemplate | undefined {
+    return this.templates.get(name);
+  }
+
+  /**
+   * List all templates
+   */
+  listTemplates(): LexiconTemplate[] {
+    return Array.from(this.templates.values());
+  }
+
+  /**
+   * Add pattern
+   */
+  addPattern(pattern: LexiconPattern): void {
+    this.patterns.set(pattern.name, pattern);
+  }
+
+  /**
+   * Get pattern by name
+   */
+  getPattern(name: string): LexiconPattern | undefined {
+    return this.patterns.get(name);
+  }
+
+  /**
+   * List all patterns
+   */
+  listPatterns(): LexiconPattern[] {
+    return Array.from(this.patterns.values());
+  }
+
+  /**
+   * Search vocabulary across domains
+   */
+  searchVocabulary(query: string, domain?: string): SearchResult[] {
+    const results: SearchResult[] = [];
+    const searchDomains = domain ? [domain] : Array.from(this.vocabulary.keys());
+
+    for (const searchDomain of searchDomains) {
+      const vocab = this.vocabulary.get(searchDomain);
+      if (vocab) {
+        for (const term of vocab.terms) {
+          if (
+            this.matchesSearch(term.name, query) ||
+            this.matchesSearch(term.definition, query)
+          ) {
+            results.push({
+              type: 'term',
+              domain: searchDomain,
+              item: term,
+              relevance: this.calculateRelevance(term.name, query),
+            });
+          }
+        }
+
+        for (const definition of vocab.definitions) {
+          if (this.matchesSearch(definition.meaning, query)) {
+            results.push({
+              type: 'definition',
+              domain: searchDomain,
+              item: definition,
+              relevance: this.calculateRelevance(definition.meaning, query),
+            });
+          }
+        }
+      }
+    }
+
+    results.sort((a, b) => b.relevance - a.relevance);
+    return results;
+  }
+
+  /**
+   * Get lexicon statistics
+   */
+  getLexiconStats(): LexiconStats {
+    return {
+      totalDomains: this.domains.size,
+      totalTerms: Array.from(this.vocabulary.values()).reduce(
+        (sum, vocab) => sum + vocab.terms.length,
+        0,
+      ),
+      totalTemplates: this.templates.size,
+      totalPatterns: this.patterns.size,
+      domains: Array.from(this.domains.keys()),
+      vocabularySizes: Object.fromEntries(
+        Array.from(this.vocabulary.entries()).map(([d, vocab]) => [d, vocab.terms.length]),
+      ),
+    };
+  }
+
+  // ─── Default Initialization ─────────────────────────────────────────
+
+  private async initializeDefaultDomains(): Promise<void> {
+    this.addDomain({
+      name: 'core',
+      description: 'Core Baseline Language concepts and vocabulary',
+      vocabulary: ['program', 'block', 'metadata', 'type', 'content'],
+      patterns: ['structure', 'validation', 'execution'],
+      examples: ['lang { ... }', 'frame { ... }', 'core { ... }'],
+    });
+
+    this.addDomain({
+      name: 'ai-ml',
+      description: 'Artificial Intelligence and Machine Learning concepts',
+      vocabulary: ['model', 'training', 'inference', 'accuracy', 'precision'],
+      patterns: ['supervised', 'unsupervised', 'reinforcement'],
+      examples: ['model { type: "llm", version: "1.0" }'],
+    });
+
+    this.addDomain({
+      name: 'business',
+      description: 'Business and enterprise concepts',
+      vocabulary: ['kpi', 'metric', 'goal', 'deliverable', 'success'],
+      patterns: ['measurement', 'tracking', 'reporting'],
+      examples: ['goal { name: "revenue", target: 1000000 }'],
+    });
+  }
+
+  private async initializeDefaultVocabulary(): Promise<void> {
+    this.addVocabulary('core', {
+      terms: [
+        {
+          name: 'program',
+          definition: 'A complete Baseline Language program',
+          synonyms: ['script', 'code', 'application'],
+          antonyms: [],
+          examples: ['Complete program structure'],
+        },
+        {
+          name: 'block',
+          definition: 'A logical section of a Baseline Language program',
+          synonyms: ['section', 'module', 'component'],
+          antonyms: [],
+          examples: ['lang block', 'frame block', 'core block'],
+        },
+      ],
+      synonyms: [],
+      antonyms: [],
+      definitions: [],
+    });
+
+    this.addVocabulary('ai-ml', {
+      terms: [
+        {
+          name: 'model',
+          definition: 'An AI or ML model for processing',
+          synonyms: ['algorithm', 'system', 'engine'],
+          antonyms: [],
+          examples: ['LLM model', 'NLP model', 'Vision model'],
+        },
+      ],
+      synonyms: [],
+      antonyms: [],
+      definitions: [],
+    });
+  }
+
+  private async initializeDefaultTemplates(): Promise<void> {
+    this.addTemplate({
+      name: 'basic-program',
+      description: 'Basic Baseline Language program structure',
+      pattern:
+        'lang { lexicon { ... } }\nframe { intent { ... } }\ncore { fidelity { ... } }',
+      variables: [
+        {
+          name: 'programName',
+          type: 'string',
+          description: 'Name of the program',
+          required: true,
+        },
+        {
+          name: 'description',
+          type: 'string',
+          description: 'Program description',
+          required: false,
+        },
+      ],
+      examples: ['Basic program with lexicon, intent, and fidelity'],
+    });
+
+    this.addTemplate({
+      name: 'intent-block',
+      description: 'Intent block with goals and deliverables',
+      pattern:
+        'intent {\n  goal {{goalName}} {\n    description: "{{goalDescription}}"\n    priority: "{{priority}}"\n  }\n}',
+      variables: [
+        {
+          name: 'goalName',
+          type: 'string',
+          description: 'Name of the goal',
+          required: true,
+        },
+        {
+          name: 'goalDescription',
+          type: 'string',
+          description: 'Description of the goal',
+          required: true,
+        },
+        {
+          name: 'priority',
+          type: 'string',
+          description: 'Priority level',
+          required: false,
+          default: 'medium',
+        },
+      ],
+      examples: ['Intent block with defined goal and priority'],
+    });
+  }
+
+  private async initializeDefaultPatterns(): Promise<void> {
+    this.addPattern({
+      name: 'block-structure',
+      description: 'Standard block structure pattern',
+      regex: '^[a-zA-Z_][a-zA-Z0-9_]*\\s*\\{[^}]*\\}$',
+      examples: ['lang { ... }', 'frame { ... }', 'core { ... }'],
+      usage: ['Program blocks', 'Content blocks', 'Configuration blocks'],
+    });
+
+    this.addPattern({
+      name: 'validation-rule',
+      description: 'Validation rule pattern',
+      regex: '^validation\\s+[a-zA-Z_][a-zA-Z0-9_]*\\s*\\{[^}]*\\}$',
+      examples: ['validation required { ... }', 'validation format { ... }'],
+      usage: ['Input validation', 'Data validation', 'Format validation'],
+    });
+  }
+
+  private async loadCoreDomainPack(): Promise<void> {
+    // Core domain pack — extensible for additional core vocabulary
+  }
+
+  private async loadAIMLDomainPack(): Promise<void> {
+    // AI/ML domain pack — extensible for ML-specific vocabulary
+  }
+
+  private async loadBusinessDomainPack(): Promise<void> {
+    // Business domain pack — extensible for business vocabulary
+  }
+
+  // ─── Search Utilities ─────────────────────────────────────────────
+
+  private matchesSearch(text: string, query: string): boolean {
+    return text.toLowerCase().includes(query.toLowerCase());
+  }
+
+  private calculateRelevance(text: string, query: string): number {
+    const textLower = text.toLowerCase();
+    const queryLower = query.toLowerCase();
+
+    if (textLower === queryLower) return 1.0;
+    if (textLower.startsWith(queryLower)) return 0.9;
+    if (textLower.includes(queryLower)) return 0.7;
+
+    const textWords = textLower.split(/\s+/);
+    const queryWords = queryLower.split(/\s+/);
+    let matches = 0;
+    for (const queryWord of queryWords) {
+      if (textWords.some((textWord) => textWord.includes(queryWord))) {
+        matches++;
+      }
+    }
+    return (matches / queryWords.length) * 0.5;
+  }
+}