@baselineos/protocol-core 1.0.0

package/src/parser/grammar.ts

@@ -0,0 +1,240 @@
+/**
+ * Baseline Language PEG Grammar
+ * Parsing Expression Grammar for the Baseline prompt engineering language
+ *
+ * @license Apache-2.0
+ */
+
+/**
+ * PEG Grammar Rules for Baseline Language
+ * These rules define how to parse .bl source files into AST nodes
+ */
+export const baselineGrammarRules: Record<string, string> = {
+  // Program structure
+  program: `program = langBlock* frameBlock* coreBlock*`,
+
+  // Top-level blocks
+  langBlock: `langBlock = "lang" "{" (lexiconBlock / syntaxBlock / commandsBlock) "}"`,
+  frameBlock: `frameBlock = "frame" "{" (intentBlock / modeBlock / environmentBlock / scopeBlock / authorityBlock / basisBlock) "}"`,
+  coreBlock: `coreBlock = "core" "{" (fidelityBlock / specBlock / artifactBlock / productBlock / planBlock / promptBlock) "}"`,
+
+  // Lang: Lexicon
+  lexiconBlock: `lexiconBlock = "lexicon" "{" domain vocabulary template* pattern* "}"`,
+  domain: `domain = "domain" ":" identifier "{" description vocabulary patterns examples "}"`,
+  vocabulary: `vocabulary = "vocabulary" "{" term* synonym* antonym* definition* "}"`,
+  template: `template = "template" identifier "{" description pattern variables examples "}"`,
+  pattern: `pattern = "pattern" identifier "{" description regex examples usage "}"`,
+
+  // Lang: Syntax
+  syntaxBlock: `syntaxBlock = "syntax" "{" grammarRule* operator* precedenceRule* "}"`,
+  grammarRule: `grammarRule = "rule" identifier "{" pattern precedence associativity "}"`,
+  operator: `operator = "operator" symbol "{" precedence associativity description "}"`,
+  precedenceRule: `precedenceRule = "precedence" level "{" operators description "}"`,
+
+  // Lang: Commands
+  commandsBlock: `commandsBlock = "commands" "{" action* directive* operation* "}"`,
+  action: `action = "action" identifier "{" description parameters examples "}"`,
+  directive: `directive = "directive" identifier "{" description parameters examples "}"`,
+  operation: `operation = "operation" identifier "{" description parameters examples "}"`,
+
+  // Frame: Intent
+  intentBlock: `intentBlock = "intent" "{" goal* deliverable* successCriterion* constraint* "}"`,
+  goal: `goal = "goal" identifier "{" description priority deadline successCriteria "}"`,
+  deliverable: `deliverable = "deliverable" identifier "{" description type format quality "}"`,
+  successCriterion: `successCriterion = "criterion" identifier "{" description metric target unit "}"`,
+  constraint: `constraint = "constraint" identifier "{" description type value enforcement "}"`,
+
+  // Frame: Mode
+  modeBlock: `modeBlock = "mode" "{" executionPattern reasoning checkpoint* iterationRule* "}"`,
+  executionPattern: `executionPattern = "pattern" identifier "{" description steps checkpoints iterations "}"`,
+  reasoningMode: `reasoningMode = "reasoning" type "{" description parameters "}"`,
+  checkpoint: `checkpoint = "checkpoint" identifier "{" description validation actions "}"`,
+  iterationRule: `iterationRule = "iteration" identifier "{" condition maxIterations convergence "}"`,
+
+  // Frame: Environment
+  environmentBlock: `environmentBlock = "environment" "{" model* tool* runtime policy* "}"`,
+  model: `model = "model" identifier "{" type version capabilities constraints "}"`,
+  tool: `tool = "tool" identifier "{" description type parameters examples "}"`,
+  runtime: `runtime = "runtime" "{" environment version resources policies "}"`,
+  policy: `policy = "policy" identifier "{" description type rules enforcement "}"`,
+
+  // Frame: Scope
+  scopeBlock: `scopeBlock = "scope" "{" boundary* limit* exclusion* inclusion* "}"`,
+  boundary: `boundary = "boundary" identifier "{" description type value enforcement "}"`,
+  limit: `limit = "limit" identifier "{" description type value unit "}"`,
+  exclusion: `exclusion = "exclusion" identifier "{" description reason alternatives "}"`,
+  inclusion: `inclusion = "inclusion" identifier "{" description reason requirements "}"`,
+
+  // Frame: Authority
+  authorityBlock: `authorityBlock = "authority" "{" role* permission* accessControl* delegationRule* "}"`,
+  role: `role = "role" identifier "{" description permissions responsibilities "}"`,
+  permission: `permission = "permission" identifier "{" description scope level "}"`,
+  accessControl: `accessControl = "access" resource "{" permissions roles conditions "}"`,
+  delegationRule: `delegationRule = "delegation" identifier "{" description fromRole toRole conditions expiration "}"`,
+
+  // Frame: Basis
+  basisBlock: `basisBlock = "basis" "{" organization kpi* metric* context* "}"`,
+  organization: `organization = "organization" "{" name description structure culture values "}"`,
+  kpi: `kpi = "kpi" identifier "{" description metric target unit frequency "}"`,
+  metric: `metric = "metric" identifier "{" description type calculation unit "}"`,
+  context: `context = "context" identifier "{" description type value source "}"`,
+
+  // Core: Fidelity
+  fidelityBlock: `fidelityBlock = "fidelity" "{" precision verification quality constraints "}"`,
+  precisionLevel: `precisionLevel = "precision" level "{" description requirements "}"`,
+  verificationLevel: `verificationLevel = "verification" level "{" description methods "}"`,
+  qualityStandard: `qualityStandard = "quality" identifier "{" description criteria measurement "}"`,
+
+  // Core: Spec
+  specBlock: `specBlock = "spec" "{" requirement* contract* interface* validation* "}"`,
+  requirement: `requirement = "requirement" identifier "{" description type priority acceptance "}"`,
+  contract: `contract = "contract" identifier "{" description parties terms enforcement "}"`,
+  interface: `interface = "interface" identifier "{" description type methods properties "}"`,
+  validation: `validation = "validation" identifier "{" description type rules errorHandling "}"`,
+
+  // Core: Artifact
+  artifactBlock: `artifactBlock = "artifact" "{" output* receipt* signature* retentionPolicy* "}"`,
+  output: `output = "output" identifier "{" description type format quality "}"`,
+  receipt: `receipt = "receipt" identifier "{" description timestamp hash signature "}"`,
+  signature: `signature = "signature" "{" algorithm value timestamp key "}"`,
+  retentionPolicy: `retentionPolicy = "retention" identifier "{" description duration conditions disposal "}"`,
+
+  // Core: Product
+  productBlock: `productBlock = "product" "{" deliverable* document* result* outcome* "}"`,
+  document: `document = "document" identifier "{" description type format content "}"`,
+  result: `result = "result" identifier "{" description type value quality "}"`,
+  outcome: `outcome = "outcome" identifier "{" description type success metrics "}"`,
+
+  // Core: Plan
+  planBlock: `planBlock = "plan" "{" roadmap timeline milestone* dependency* "}"`,
+  roadmap: `roadmap = "roadmap" "{" name description phases timeline milestones "}"`,
+  timeline: `timeline = "timeline" "{" start end phases dependencies "}"`,
+  milestone: `milestone = "milestone" identifier "{" description date deliverables successCriteria "}"`,
+  dependency: `dependency = "dependency" identifier "{" description from to type critical "}"`,
+
+  // Core: Prompt (IR)
+  promptBlock: `promptBlock = "prompt" "{" ir instruction* context* constraint* "}"`,
+  intermediateRepresentation: `intermediateRepresentation = "ir" "{" version blocks metadata optimizations "}"`,
+  instruction: `instruction = "instruction" identifier "{" description type parameters examples "}"`,
+
+  // Utility elements
+  parameter: `parameter = "parameter" identifier "{" type description required default validation "}"`,
+  term: `term = "term" identifier "{" definition synonyms antonyms examples "}"`,
+  synonym: `synonym = "synonym" term "{" alternatives context "}"`,
+  antonym: `antonym = "antonym" term "{" opposites context "}"`,
+  definition: `definition = "definition" term "{" meaning context examples "}"`,
+  variable: `variable = "variable" identifier "{" type description required default "}"`,
+  step: `step = "step" identifier "{" description action validation next "}"`,
+  convergenceCriteria: `convergenceCriteria = "convergence" "{" metric threshold tolerance maxIterations "}"`,
+  capability: `capability = "capability" identifier "{" description parameters examples "}"`,
+  resource: `resource = "resource" "{" type name capacity unit available "}"`,
+  rule: `rule = "rule" identifier "{" description condition action priority "}"`,
+  condition: `condition = "condition" identifier "{" description expression parameters "}"`,
+  structure: `structure = "structure" "{" type levels departments reporting "}"`,
+  culture: `culture = "culture" "{" values principles practices norms "}"`,
+  value: `value = "value" identifier "{" description importance examples "}"`,
+  phase: `phase = "phase" identifier "{" description start end deliverables milestones "}"`,
+  optimization: `optimization = "optimization" identifier "{" description type impact implementation "}"`,
+  errorHandling: `errorHandling = "errorHandling" "{" strategy fallback logging userNotification "}"`,
+  method: `method = "method" identifier "{" description parameters returnType examples "}"`,
+  property: `property = "property" identifier "{" description type required default "}"`,
+  acceptanceCriteria: `acceptanceCriteria = "criteria" identifier "{" description test passCondition priority "}"`,
+
+  // Primitives
+  identifier: `identifier = [a-zA-Z_][a-zA-Z0-9_]*`,
+  description: `description = "description" ":" string`,
+  string: `string = '"' [^"]* '"'`,
+  number: `number = [0-9]+ ("." [0-9]+)?`,
+  boolean: `boolean = "true" / "false"`,
+  date: `date = [0-9]{4}-[0-9]{2}-[0-9]{2}`,
+  time: `time = [0-9]{2}:[0-9]{2}:[0-9]{2}`,
+  datetime: `datetime = date "T" time`,
+  array: `array = "[" (valueElement ("," valueElement)*)? "]"`,
+  object: `object = "{" (pair ("," pair)*)? "}"`,
+  pair: `pair = key ":" valueElement`,
+  key: `key = identifier / string`,
+  valueElement: `valueElement = string / number / boolean / date / time / datetime / array / object / identifier`,
+};
+
+/**
+ * Grammar validation utilities
+ */
+export class GrammarValidator {
+  static validateRule(rule: string): boolean {
+    const stack: string[] = [];
+    const pairs: Record<string, string> = { '(': ')', '[': ']', '{': '}' };
+
+    for (const char of rule) {
+      if (pairs[char]) {
+        stack.push(char);
+      } else if (Object.values(pairs).includes(char)) {
+        const open = stack.pop();
+        if (!open || pairs[open] !== char) {
+          return false;
+        }
+      }
+    }
+    return stack.length === 0;
+  }
+
+  static extractReferencedRules(rule: string): string[] {
+    const referencedRules: string[] = [];
+    const rulePattern = /[a-zA-Z_][a-zA-Z0-9_]*/g;
+    let match: RegExpExecArray | null;
+    while ((match = rulePattern.exec(rule)) !== null) {
+      const ruleName = match[0];
+      if (!['true', 'false', 'null'].includes(ruleName)) {
+        referencedRules.push(ruleName);
+      }
+    }
+    return referencedRules;
+  }
+
+  static hasRecursion(ruleName: string, grammar: Record<string, string>): boolean {
+    const visited = new Set<string>();
+    const recursionStack = new Set<string>();
+
+    const check = (name: string): boolean => {
+      if (recursionStack.has(name)) return true;
+      if (visited.has(name)) return false;
+
+      visited.add(name);
+      recursionStack.add(name);
+
+      const ruleContent = grammar[name];
+      if (ruleContent) {
+        if (ruleContent.includes(name)) return true;
+        for (const ref of this.extractReferencedRules(ruleContent)) {
+          if (check(ref)) return true;
+        }
+      }
+
+      recursionStack.delete(name);
+      return false;
+    };
+
+    return check(ruleName);
+  }
+
+  static generateSummary(grammar: Record<string, string>) {
+    const rules = Object.keys(grammar);
+    return {
+      totalRules: rules.length,
+      ruleTypes: {
+        structural: rules.filter(r => r.includes('Block') || r.includes('Program')),
+        lexical: rules.filter(r => r.includes('Lexicon') || r.includes('Vocabulary')),
+        syntactic: rules.filter(r => r.includes('Syntax') || r.includes('Grammar')),
+        semantic: rules.filter(r => r.includes('Intent') || r.includes('Mode')),
+        execution: rules.filter(r => r.includes('Core') || r.includes('Prompt')),
+      },
+      hasRecursion: rules.some(r => this.hasRecursion(r, grammar)),
+      validationStatus: rules.every(r => this.validateRule(grammar[r])),
+    };
+  }
+}
+
+export const baselineGrammar = {
+  rules: baselineGrammarRules,
+  validator: GrammarValidator,
+  summary: () => GrammarValidator.generateSummary(baselineGrammarRules),
+};

package/src/parser/parser.ts

@@ -0,0 +1,420 @@
+/**
+ * Baseline Language Parser
+ * PEG-based parser for Baseline Language syntax
+ *
+ * @license Apache-2.0
+ */
+
+import type {
+  BaselineProgram,
+  ProgramMetadata,
+  BlockMetadata,
+  Priority,
+} from '../types/index.js';
+
+// ─── Token Types ────────────────────────────────────────────────────
+
+export type TokenType = 'IDENTIFIER' | 'STRING' | 'NUMBER' | 'OPERATOR' | 'EOF';
+
+export interface Token {
+  type: TokenType;
+  value: string;
+  position: number;
+}
+
+// ─── Block Content Types ────────────────────────────────────────────
+
+export interface LangBlockContent {
+  type: 'lexicon';
+  domain: string;
+  vocabulary: unknown[];
+  templates: unknown[];
+  patterns: unknown[];
+}
+
+export interface FrameBlockContent {
+  type: 'intent';
+  goals: unknown[];
+  deliverables: unknown[];
+  successCriteria: unknown[];
+  constraints: unknown[];
+}
+
+export interface CoreBlockContent {
+  type: 'fidelity';
+  precision: string;
+  verification: string;
+  quality: unknown[];
+  constraints: unknown[];
+}
+
+export type ParsedBlock = {
+  type: 'lang' | 'frame' | 'core';
+  content: LangBlockContent | FrameBlockContent | CoreBlockContent;
+  metadata: BlockMetadata;
+};
+
+// ─── Parser ─────────────────────────────────────────────────────────
+
+export class BaselineParser {
+  private tokens: Token[] = [];
+  private currentPosition = 0;
+  private grammar: unknown = null;
+
+  async initialize(): Promise<void> {
+    await this.initializeGrammar();
+  }
+
+  /**
+   * Parse Baseline Language source code
+   */
+  async parse(source: string): Promise<BaselineProgram> {
+    try {
+      this.tokens = this.tokenize(source);
+      this.currentPosition = 0;
+      const program = await this.parseProgram();
+      return program;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Parsing failed: ${errorMessage}`);
+    }
+  }
+
+  /**
+   * Tokenize source code into tokens
+   */
+  tokenize(source: string): Token[] {
+    const tokens: Token[] = [];
+    let position = 0;
+
+    while (position < source.length) {
+      const char = source[position];
+
+      // Skip whitespace
+      if (/\s/.test(char)) {
+        position++;
+        continue;
+      }
+
+      // Handle single-line comments
+      if (char === '/' && source[position + 1] === '/') {
+        const commentEnd = source.indexOf('\n', position);
+        if (commentEnd === -1) {
+          position = source.length;
+        } else {
+          position = commentEnd + 1;
+        }
+        continue;
+      }
+
+      // Handle multi-line comments
+      if (char === '/' && source[position + 1] === '*') {
+        const commentEnd = source.indexOf('*/', position);
+        if (commentEnd === -1) {
+          throw new Error('Unterminated multi-line comment');
+        }
+        position = commentEnd + 2;
+        continue;
+      }
+
+      // Handle identifiers
+      if (/[a-zA-Z_]/.test(char)) {
+        const identifier = this.extractIdentifier(source, position);
+        tokens.push({
+          type: 'IDENTIFIER',
+          value: identifier,
+          position,
+        });
+        position += identifier.length;
+        continue;
+      }
+
+      // Handle strings
+      if (char === '"') {
+        const str = this.extractString(source, position);
+        tokens.push({
+          type: 'STRING',
+          value: str,
+          position,
+        });
+        position += str.length + 2; // +2 for quotes
+        continue;
+      }
+
+      // Handle numbers
+      if (/[0-9]/.test(char)) {
+        const num = this.extractNumber(source, position);
+        tokens.push({
+          type: 'NUMBER',
+          value: num,
+          position,
+        });
+        position += num.length;
+        continue;
+      }
+
+      // Handle operators and punctuation
+      if (this.isOperator(char) || this.isPunctuation(char)) {
+        tokens.push({
+          type: 'OPERATOR',
+          value: char,
+          position,
+        });
+        position++;
+        continue;
+      }
+
+      throw new Error(`Unknown character at position ${position}: ${char}`);
+    }
+
+    // Add EOF token
+    tokens.push({
+      type: 'EOF',
+      value: '',
+      position,
+    });
+
+    return tokens;
+  }
+
+  /**
+   * Parse program structure
+   */
+  private async parseProgram(): Promise<BaselineProgram> {
+    const blocks: ParsedBlock[] = [];
+
+    while (this.currentToken().type !== 'EOF') {
+      const block = await this.parseBlock();
+      if (block) {
+        blocks.push(block);
+      }
+    }
+
+    const metadata: ProgramMetadata = {
+      version: '1.0.0',
+      created: new Date(),
+      author: 'Baseline Lang',
+      description: 'Generated Baseline Language program',
+      tags: ['baseline', 'lang', 'generated'],
+    };
+
+    return {
+      blocks: blocks as unknown as BaselineProgram['blocks'],
+      metadata,
+    };
+  }
+
+  /**
+   * Parse individual block
+   */
+  private async parseBlock(): Promise<ParsedBlock | null> {
+    const token = this.currentToken();
+    if (token.type === 'IDENTIFIER') {
+      switch (token.value) {
+        case 'lang':
+          return await this.parseLangBlock();
+        case 'frame':
+          return await this.parseFrameBlock();
+        case 'core':
+          return await this.parseCoreBlock();
+        default:
+          throw new Error(`Unknown block type: ${token.value}`);
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Parse language block
+   */
+  private async parseLangBlock(): Promise<ParsedBlock> {
+    this.expect('IDENTIFIER', 'lang');
+    this.expect('OPERATOR', '{');
+    const content = await this.parseLangBlockContent();
+    this.expect('OPERATOR', '}');
+
+    return {
+      type: 'lang',
+      content,
+      metadata: this.createBlockMetadata('lang'),
+    };
+  }
+
+  /**
+   * Parse frame block
+   */
+  private async parseFrameBlock(): Promise<ParsedBlock> {
+    this.expect('IDENTIFIER', 'frame');
+    this.expect('OPERATOR', '{');
+    const content = await this.parseFrameBlockContent();
+    this.expect('OPERATOR', '}');
+
+    return {
+      type: 'frame',
+      content,
+      metadata: this.createBlockMetadata('frame'),
+    };
+  }
+
+  /**
+   * Parse core block
+   */
+  private async parseCoreBlock(): Promise<ParsedBlock> {
+    this.expect('IDENTIFIER', 'core');
+    this.expect('OPERATOR', '{');
+    const content = await this.parseCoreBlockContent();
+    this.expect('OPERATOR', '}');
+
+    return {
+      type: 'core',
+      content,
+      metadata: this.createBlockMetadata('core'),
+    };
+  }
+
+  /**
+   * Parse language block content
+   * TODO: Full implementation should parse lexicon, syntax, and commands
+   */
+  private async parseLangBlockContent(): Promise<LangBlockContent> {
+    while (this.currentPosition < this.tokens.length && this.currentToken().type !== 'EOF') {
+      const token = this.currentToken();
+      if (token.type === 'OPERATOR' && token.value === '}') {
+        break;
+      }
+      this.currentPosition++;
+    }
+
+    return {
+      type: 'lexicon',
+      domain: 'default',
+      vocabulary: [],
+      templates: [],
+      patterns: [],
+    };
+  }
+
+  /**
+   * Parse frame block content
+   * TODO: Full implementation should parse intent, mode, environment, etc.
+   */
+  private async parseFrameBlockContent(): Promise<FrameBlockContent> {
+    while (this.currentPosition < this.tokens.length && this.currentToken().type !== 'EOF') {
+      const token = this.currentToken();
+      if (token.type === 'OPERATOR' && token.value === '}') {
+        break;
+      }
+      this.currentPosition++;
+    }
+
+    return {
+      type: 'intent',
+      goals: [],
+      deliverables: [],
+      successCriteria: [],
+      constraints: [],
+    };
+  }
+
+  /**
+   * Parse core block content
+   * TODO: Full implementation should parse fidelity, spec, artifact, etc.
+   */
+  private async parseCoreBlockContent(): Promise<CoreBlockContent> {
+    while (this.currentPosition < this.tokens.length && this.currentToken().type !== 'EOF') {
+      const token = this.currentToken();
+      if (token.type === 'OPERATOR' && token.value === '}') {
+        break;
+      }
+      this.currentPosition++;
+    }
+
+    return {
+      type: 'fidelity',
+      precision: 'medium',
+      verification: 'standard',
+      quality: [],
+      constraints: [],
+    };
+  }
+
+  // ─── Helper Methods ─────────────────────────────────────────────────
+
+  private extractIdentifier(source: string, position: number): string {
+    let end = position;
+    while (end < source.length && /[a-zA-Z0-9_]/.test(source[end])) {
+      end++;
+    }
+    return source.substring(position, end);
+  }
+
+  private extractString(source: string, position: number): string {
+    let end = position + 1;
+    while (end < source.length && source[end] !== '"') {
+      if (source[end] === '\\') {
+        end += 2; // Skip escaped character
+      } else {
+        end++;
+      }
+    }
+    if (end >= source.length) {
+      throw new Error('Unterminated string');
+    }
+    return source.substring(position + 1, end);
+  }
+
+  private extractNumber(source: string, position: number): string {
+    let end = position;
+    while (end < source.length && /[0-9]/.test(source[end])) {
+      end++;
+    }
+    if (end < source.length && source[end] === '.') {
+      end++;
+      while (end < source.length && /[0-9]/.test(source[end])) {
+        end++;
+      }
+    }
+    return source.substring(position, end);
+  }
+
+  private isOperator(char: string): boolean {
+    return /[+\-*/=<>!&|]/.test(char);
+  }
+
+  private isPunctuation(char: string): boolean {
+    return /[(){}[\],;:.]/.test(char);
+  }
+
+  private currentToken(): Token {
+    return this.tokens[this.currentPosition];
+  }
+
+  private expect(type: TokenType, value?: string): void {
+    const token = this.currentToken();
+    if (token.type !== type) {
+      throw new Error(`Expected ${type}, got ${token.type}`);
+    }
+    if (value && token.value !== value) {
+      throw new Error(`Expected ${value}, got ${token.value}`);
+    }
+    this.currentPosition++;
+  }
+
+  private createBlockMetadata(type: string): BlockMetadata {
+    return {
+      id: `${type}_${Date.now()}`,
+      name: `${type} block`,
+      description: `Generated ${type} block`,
+      version: '1.0.0',
+      created: new Date(),
+      modified: new Date(),
+      tags: [type, 'generated'],
+      priority: 'medium' as Priority,
+    };
+  }
+
+  private async initializeGrammar(): Promise<void> {
+    // Initialize PEG grammar
+    // In full implementation, this would load and validate grammar rules
+  }
+}