openagentflow 0.1.0

package/compiler/compiler.js

@@ -0,0 +1,134 @@
+/**
+ * OpenAgentFlow Compiler — Unified Pipeline
+ *
+ * Orchestrates the full compilation pipeline:
+ *   1. Lexical Analysis  (Lexer)
+ *   2. Parsing            (Parser → AST)
+ *   3. Semantic Validation (Validator)
+ *   4. IR Generation       (IRGenerator)
+ *
+ * Each stage can be invoked independently or the full pipeline can be run
+ * via the `compile()` method.
+ */
+
+import { Lexer } from '../parser/lexer.js';
+import { Parser } from '../parser/parser.js';
+import { SemanticValidator } from './validator.js';
+import { IRGenerator } from './ir-generator.js';
+
+// ─── Compilation Result ────────────────────────────────────────────────────────
+
+export class CompilationResult {
+  constructor() {
+    /** @type {import('../parser/lexer.js').Token[]|null} */
+    this.tokens = null;
+
+    /** @type {import('../parser/ast.js').Program|null} */
+    this.ast = null;
+
+    /** @type {import('./validator.js').ValidationResult|null} */
+    this.validation = null;
+
+    /** @type {object|null} */
+    this.ir = null;
+
+    /** @type {Error|null} */
+    this.error = null;
+
+    /** @type {'success'|'lexer_error'|'parse_error'|'validation_error'|'error'} */
+    this.status = 'success';
+  }
+}
+
+// ─── Compiler ──────────────────────────────────────────────────────────────────
+
+export class Compiler {
+  /**
+   * @param {string} source - The .oaf source text
+   * @param {string} [filename='<input>'] - Filename for diagnostics
+   */
+  constructor(source, filename = '<input>') {
+    this.source = source;
+    this.filename = filename;
+  }
+
+  /**
+   * Run the full compilation pipeline.
+   * @returns {CompilationResult}
+   */
+  compile() {
+    const result = new CompilationResult();
+
+    try {
+      // Stage 1: Lexical Analysis
+      result.tokens = this.lex();
+
+      // Stage 2: Parsing
+      result.ast = this.parse(result.tokens);
+
+      // Stage 3: Semantic Validation
+      result.validation = this.validate(result.ast);
+
+      if (!result.validation.isValid) {
+        result.status = 'validation_error';
+        return result;
+      }
+
+      // Stage 4: IR Generation
+      result.ir = this.generateIR(result.ast);
+
+      result.status = 'success';
+    } catch (err) {
+      result.error = err;
+
+      if (err.name === 'LexerError') {
+        result.status = 'lexer_error';
+      } else if (err.name === 'ParseError') {
+        result.status = 'parse_error';
+      } else {
+        result.status = 'error';
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Stage 1: Tokenize the source.
+   * @returns {import('../parser/lexer.js').Token[]}
+   */
+  lex() {
+    const lexer = new Lexer(this.source, this.filename);
+    return lexer.tokenize();
+  }
+
+  /**
+   * Stage 2: Parse tokens into an AST.
+   * @param {import('../parser/lexer.js').Token[]} tokens
+   * @returns {import('../parser/ast.js').Program}
+   */
+  parse(tokens) {
+    const parser = new Parser(tokens);
+    return parser.parse();
+  }
+
+  /**
+   * Stage 3: Validate the AST semantically.
+   * @param {import('../parser/ast.js').Program} ast
+   * @returns {import('./validator.js').ValidationResult}
+   */
+  validate(ast) {
+    const validator = new SemanticValidator(ast, this.filename);
+    return validator.validate();
+  }
+
+  /**
+   * Stage 4: Generate the IR from a validated AST.
+   * @param {import('../parser/ast.js').Program} ast
+   * @returns {object}
+   */
+  generateIR(ast) {
+    const generator = new IRGenerator(ast);
+    return generator.generate();
+  }
+}

package/compiler/index.js

@@ -0,0 +1,7 @@
+/**
+ * OpenAgentFlow Compiler — Public API
+ */
+
+export { Compiler, CompilationResult } from './compiler.js';
+export { SemanticValidator, Diagnostic, ValidationResult } from './validator.js';
+export { IRGenerator } from './ir-generator.js';

package/compiler/ir-generator.js

@@ -0,0 +1,142 @@
+/**
+ * OpenAgentFlow IR Generator
+ *
+ * Transforms a validated AST into the Intermediate Representation (IR).
+ * The IR is a plain JSON-serializable object conforming to the IR spec.
+ *
+ * Pipeline: Validated AST → [IR Generator] → IR (JSON)
+ */
+
+const IR_VERSION = '0.1.0';
+
+export class IRGenerator {
+  /**
+   * @param {import('../parser/ast.js').Program} ast - The validated AST
+   */
+  constructor(ast) {
+    this.ast = ast;
+  }
+
+  /**
+   * Generate the IR from the AST.
+   * @returns {object} IR document
+   */
+  generate() {
+    const workflow = this.ast.workflow;
+
+    return {
+      version: IR_VERSION,
+      workflow: this.buildWorkflowMeta(workflow),
+      state: this.buildState(workflow.state),
+      agents: this.buildAgents(workflow.agents),
+      graph: this.buildGraph(workflow.flow),
+    };
+  }
+
+  // ── Workflow Metadata ───────────────────────────────────────────────────────
+
+  buildWorkflowMeta(workflow) {
+    const config = {};
+    if (workflow.config) {
+      for (const entry of workflow.config.entries) {
+        config[entry.key] = entry.value;
+      }
+    }
+    return {
+      name: workflow.name,
+      config,
+    };
+  }
+
+  // ── State ───────────────────────────────────────────────────────────────────
+
+  buildState(stateBlock) {
+    if (!stateBlock) {
+      return { variables: [] };
+    }
+
+    return {
+      variables: stateBlock.fields.map(field => ({
+        name: field.name,
+        type: this.serializeType(field.typeExpr),
+        options: (field.options ?? []).map(opt => ({
+          name: opt.name,
+          args: opt.args ?? [],
+        })),
+      })),
+    };
+  }
+
+  /**
+   * Convert a TypeExpr AST node into an IR type descriptor string.
+   * @param {import('../parser/ast.js').TypeExpr} typeExpr
+   * @returns {string}
+   */
+  serializeType(typeExpr) {
+    switch (typeExpr.kind) {
+      case 'primitive':
+        return typeExpr.name;
+      case 'list':
+        return `list<${this.serializeType(typeExpr.elementType)}>`;
+      case 'map':
+        return `map<${this.serializeType(typeExpr.keyType)},${this.serializeType(typeExpr.valueType)}>`;
+      default:
+        return 'unknown';
+    }
+  }
+
+  // ── Agents ──────────────────────────────────────────────────────────────────
+
+  buildAgents(agents) {
+    return agents.map(agent => {
+      let provider = agent.provider ?? null;
+      if (!provider && agent.model) {
+        if (agent.model.startsWith('claude-')) provider = 'anthropic';
+        else if (agent.model.startsWith('gpt-') || agent.model.startsWith('o1') || agent.model.startsWith('o3')) provider = 'openai';
+        else if (agent.model.startsWith('gemini-') || agent.model.startsWith('gemma-')) provider = 'gemini';
+      }
+      return {
+        id: agent.id,
+        instructions: agent.instructions,
+        model: agent.model,
+        provider,
+        temperature: agent.temperature,
+        tools: agent.tools,
+        inputs: agent.inputs,
+        outputs: agent.outputs,
+      };
+    });
+  }
+
+  // ── Graph ───────────────────────────────────────────────────────────────────
+
+  buildGraph(flowBlock) {
+    if (!flowBlock) {
+      return { edges: [], entrypoint: null, terminals: [] };
+    }
+
+    // Find entrypoint: the target of the start edge
+    let entrypoint = null;
+    const terminals = [];
+    const agentEdges = [];
+
+    for (const edge of flowBlock.edges) {
+      if (edge.source === 'start') {
+        entrypoint = edge.target;
+      } else if (edge.target === 'end') {
+        terminals.push(edge.source);
+      } else {
+        agentEdges.push({
+          source: edge.source,
+          target: edge.target,
+        });
+      }
+    }
+
+    return {
+      edges: agentEdges,
+      entrypoint,
+      terminals,
+    };
+  }
+}