@baselineos/protocol-core 1.0.0

package/dist/index.js

@@ -0,0 +1,2653 @@
+// src/lang/lang.ts
+var BaselineLang = class {
+  parser;
+  lexicon;
+  constructor(parser, lexicon) {
+    this.parser = parser;
+    this.lexicon = lexicon;
+  }
+  async initialize() {
+    await this.initializeLanguageComponents();
+    await this.initializeDefaultLexicons();
+    await this.initializeLanguagePatterns();
+  }
+  /**
+   * Get the lexicon instance
+   */
+  getLexicon() {
+    return this.lexicon;
+  }
+  /**
+   * Parse Baseline Language source code
+   */
+  async parseSource(source) {
+    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) {
+    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) {
+    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) {
+    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, variables) {
+    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() {
+    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 ─────────────────────────────────────────
+  async initializeLanguageComponents() {
+    await this.initializeLexiconSystem();
+    await this.initializeSyntaxSystem();
+    await this.initializeCommandSystem();
+  }
+  async initializeDefaultLexicons() {
+    await this.lexicon.loadDefaultPacks();
+  }
+  async initializeLanguagePatterns() {
+    await this.initializePatterns();
+  }
+  async initializeLexiconSystem() {
+  }
+  async initializeSyntaxSystem() {
+  }
+  async initializeCommandSystem() {
+  }
+  async initializePatterns() {
+  }
+  async compileProgram(program) {
+    return {
+      version: "1.0.0",
+      blocks: program.blocks,
+      metadata: program.metadata,
+      optimizations: []
+    };
+  }
+  async executeIR(_ir) {
+    return {
+      success: true,
+      outputs: [],
+      metrics: {},
+      timestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  async validateProgram(program) {
+    const validation = {
+      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;
+  }
+  async validateBlock(block) {
+    const validation = {
+      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;
+  }
+  async generateLanguage(template, variables) {
+    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;
+  }
+  async calculateLanguageStats() {
+    return {
+      totalBlocks: 0,
+      blockTypes: {},
+      lexiconSize: 0,
+      patternCount: 0,
+      templateCount: 0,
+      complexity: "low"
+    };
+  }
+};
+
+// src/parser/parser.ts
+var BaselineParser = class {
+  tokens = [];
+  currentPosition = 0;
+  grammar = null;
+  async initialize() {
+    await this.initializeGrammar();
+  }
+  /**
+   * Parse Baseline Language source code
+   */
+  async parse(source) {
+    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) {
+    const tokens = [];
+    let position = 0;
+    while (position < source.length) {
+      const char = source[position];
+      if (/\s/.test(char)) {
+        position++;
+        continue;
+      }
+      if (char === "/" && source[position + 1] === "/") {
+        const commentEnd = source.indexOf("\n", position);
+        if (commentEnd === -1) {
+          position = source.length;
+        } else {
+          position = commentEnd + 1;
+        }
+        continue;
+      }
+      if (char === "/" && source[position + 1] === "*") {
+        const commentEnd = source.indexOf("*/", position);
+        if (commentEnd === -1) {
+          throw new Error("Unterminated multi-line comment");
+        }
+        position = commentEnd + 2;
+        continue;
+      }
+      if (/[a-zA-Z_]/.test(char)) {
+        const identifier = this.extractIdentifier(source, position);
+        tokens.push({
+          type: "IDENTIFIER",
+          value: identifier,
+          position
+        });
+        position += identifier.length;
+        continue;
+      }
+      if (char === '"') {
+        const str = this.extractString(source, position);
+        tokens.push({
+          type: "STRING",
+          value: str,
+          position
+        });
+        position += str.length + 2;
+        continue;
+      }
+      if (/[0-9]/.test(char)) {
+        const num = this.extractNumber(source, position);
+        tokens.push({
+          type: "NUMBER",
+          value: num,
+          position
+        });
+        position += num.length;
+        continue;
+      }
+      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}`);
+    }
+    tokens.push({
+      type: "EOF",
+      value: "",
+      position
+    });
+    return tokens;
+  }
+  /**
+   * Parse program structure
+   */
+  async parseProgram() {
+    const blocks = [];
+    while (this.currentToken().type !== "EOF") {
+      const block = await this.parseBlock();
+      if (block) {
+        blocks.push(block);
+      }
+    }
+    const metadata = {
+      version: "1.0.0",
+      created: /* @__PURE__ */ new Date(),
+      author: "Baseline Lang",
+      description: "Generated Baseline Language program",
+      tags: ["baseline", "lang", "generated"]
+    };
+    return {
+      blocks,
+      metadata
+    };
+  }
+  /**
+   * Parse individual block
+   */
+  async parseBlock() {
+    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
+   */
+  async parseLangBlock() {
+    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
+   */
+  async parseFrameBlock() {
+    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
+   */
+  async parseCoreBlock() {
+    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
+   */
+  async parseLangBlockContent() {
+    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.
+   */
+  async parseFrameBlockContent() {
+    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.
+   */
+  async parseCoreBlockContent() {
+    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 ─────────────────────────────────────────────────
+  extractIdentifier(source, position) {
+    let end = position;
+    while (end < source.length && /[a-zA-Z0-9_]/.test(source[end])) {
+      end++;
+    }
+    return source.substring(position, end);
+  }
+  extractString(source, position) {
+    let end = position + 1;
+    while (end < source.length && source[end] !== '"') {
+      if (source[end] === "\\") {
+        end += 2;
+      } else {
+        end++;
+      }
+    }
+    if (end >= source.length) {
+      throw new Error("Unterminated string");
+    }
+    return source.substring(position + 1, end);
+  }
+  extractNumber(source, position) {
+    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);
+  }
+  isOperator(char) {
+    return /[+\-*/=<>!&|]/.test(char);
+  }
+  isPunctuation(char) {
+    return /[(){}[\],;:.]/.test(char);
+  }
+  currentToken() {
+    return this.tokens[this.currentPosition];
+  }
+  expect(type, value) {
+    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++;
+  }
+  createBlockMetadata(type) {
+    return {
+      id: `${type}_${Date.now()}`,
+      name: `${type} block`,
+      description: `Generated ${type} block`,
+      version: "1.0.0",
+      created: /* @__PURE__ */ new Date(),
+      modified: /* @__PURE__ */ new Date(),
+      tags: [type, "generated"],
+      priority: "medium"
+    };
+  }
+  async initializeGrammar() {
+  }
+};
+
+// src/lexicon/lexicon.ts
+var BaselineLexicon = class {
+  domains = /* @__PURE__ */ new Map();
+  vocabulary = /* @__PURE__ */ new Map();
+  templates = /* @__PURE__ */ new Map();
+  patterns = /* @__PURE__ */ new Map();
+  async initialize() {
+    await this.initializeDefaultDomains();
+    await this.initializeDefaultVocabulary();
+    await this.initializeDefaultTemplates();
+    await this.initializeDefaultPatterns();
+  }
+  /**
+   * Load default lexicon packs
+   */
+  async loadDefaultPacks() {
+    await this.loadCoreDomainPack();
+    await this.loadAIMLDomainPack();
+    await this.loadBusinessDomainPack();
+  }
+  /**
+   * Add a new domain
+   */
+  addDomain(domain) {
+    this.domains.set(domain.name, domain);
+  }
+  /**
+   * Get domain by name
+   */
+  getDomain(name) {
+    return this.domains.get(name);
+  }
+  /**
+   * List all domains
+   */
+  listDomains() {
+    return Array.from(this.domains.values());
+  }
+  /**
+   * Add vocabulary set
+   */
+  addVocabulary(domain, vocabulary) {
+    this.vocabulary.set(domain, vocabulary);
+  }
+  /**
+   * Get vocabulary for domain
+   */
+  getVocabulary(domain) {
+    return this.vocabulary.get(domain);
+  }
+  /**
+   * Add template
+   */
+  addTemplate(template) {
+    this.templates.set(template.name, template);
+  }
+  /**
+   * Get template by name
+   */
+  getTemplate(name) {
+    return this.templates.get(name);
+  }
+  /**
+   * List all templates
+   */
+  listTemplates() {
+    return Array.from(this.templates.values());
+  }
+  /**
+   * Add pattern
+   */
+  addPattern(pattern) {
+    this.patterns.set(pattern.name, pattern);
+  }
+  /**
+   * Get pattern by name
+   */
+  getPattern(name) {
+    return this.patterns.get(name);
+  }
+  /**
+   * List all patterns
+   */
+  listPatterns() {
+    return Array.from(this.patterns.values());
+  }
+  /**
+   * Search vocabulary across domains
+   */
+  searchVocabulary(query, domain) {
+    const results = [];
+    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() {
+    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 ─────────────────────────────────────────
+  async initializeDefaultDomains() {
+    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 }']
+    });
+  }
+  async initializeDefaultVocabulary() {
+    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: []
+    });
+  }
+  async initializeDefaultTemplates() {
+    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"]
+    });
+  }
+  async initializeDefaultPatterns() {
+    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"]
+    });
+  }
+  async loadCoreDomainPack() {
+  }
+  async loadAIMLDomainPack() {
+  }
+  async loadBusinessDomainPack() {
+  }
+  // ─── Search Utilities ─────────────────────────────────────────────
+  matchesSearch(text, query) {
+    return text.toLowerCase().includes(query.toLowerCase());
+  }
+  calculateRelevance(text, query) {
+    const textLower = text.toLowerCase();
+    const queryLower = query.toLowerCase();
+    if (textLower === queryLower) return 1;
+    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;
+  }
+};
+
+// src/parser/grammar.ts
+var baselineGrammarRules = {
+  // 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`
+};
+var GrammarValidator = class {
+  static validateRule(rule) {
+    const stack = [];
+    const pairs = { "(": ")", "[": "]", "{": "}" };
+    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) {
+    const referencedRules = [];
+    const rulePattern = /[a-zA-Z_][a-zA-Z0-9_]*/g;
+    let match;
+    while ((match = rulePattern.exec(rule)) !== null) {
+      const ruleName = match[0];
+      if (!["true", "false", "null"].includes(ruleName)) {
+        referencedRules.push(ruleName);
+      }
+    }
+    return referencedRules;
+  }
+  static hasRecursion(ruleName, grammar) {
+    const visited = /* @__PURE__ */ new Set();
+    const recursionStack = /* @__PURE__ */ new Set();
+    const check = (name) => {
+      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) {
+    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]))
+    };
+  }
+};
+var baselineGrammar = {
+  rules: baselineGrammarRules,
+  validator: GrammarValidator,
+  summary: () => GrammarValidator.generateSummary(baselineGrammarRules)
+};
+
+// src/knowledge/knowledge-graph.ts
+import { EventEmitter } from "events";
+var KnowledgeGraphEngine = class extends EventEmitter {
+  config;
+  nodes;
+  relationships;
+  personaKnowledge;
+  knowledgePatterns;
+  agents;
+  chains;
+  tools;
+  metrics;
+  constructor(config = {}) {
+    super();
+    this.config = {
+      maxNodes: config.maxNodes ?? 1e4,
+      maxRelationships: config.maxRelationships ?? 5e4,
+      knowledgeRetention: config.knowledgeRetention ?? 0.95,
+      reasoningDepth: config.reasoningDepth ?? 5,
+      vectorStore: config.vectorStore ?? {}
+    };
+    this.nodes = /* @__PURE__ */ new Map();
+    this.relationships = /* @__PURE__ */ new Map();
+    this.personaKnowledge = /* @__PURE__ */ new Map();
+    this.knowledgePatterns = /* @__PURE__ */ new Map();
+    this.agents = /* @__PURE__ */ new Map();
+    this.chains = /* @__PURE__ */ new Map();
+    this.tools = /* @__PURE__ */ new Map();
+    this.metrics = {
+      totalNodes: 0,
+      totalRelationships: 0,
+      knowledgeQueries: 0,
+      reasoningOperations: 0,
+      lastOptimization: Date.now()
+    };
+  }
+  // ── Initialization ──────────────────────────────────────────────────────────
+  async initializeEngine() {
+    console.log("[KnowledgeGraph] Initializing knowledge graph engine...");
+    this.initializeKnowledgeStructures();
+    this.initializeAgents();
+    this.initializeChains();
+    this.initializeTools();
+    console.log("[KnowledgeGraph] Knowledge graph engine initialized.");
+    this.emit("initialized", { metrics: this.metrics });
+  }
+  initializeKnowledgeStructures() {
+    const rootNode = this.createNode({
+      id: "root",
+      type: "root",
+      name: "Knowledge Root",
+      level: 0,
+      properties: { description: "Root node of the knowledge graph" },
+      confidence: 1,
+      tags: ["root", "system"]
+    });
+    const conceptNode = this.createNode({
+      id: "concepts",
+      type: "category",
+      name: "Concepts",
+      level: 1,
+      properties: { description: "Abstract concepts and ideas" },
+      confidence: 1,
+      tags: ["category", "concepts"]
+    });
+    const entityNode = this.createNode({
+      id: "entities",
+      type: "category",
+      name: "Entities",
+      level: 1,
+      properties: { description: "Concrete entities and objects" },
+      confidence: 1,
+      tags: ["category", "entities"]
+    });
+    const processNode = this.createNode({
+      id: "processes",
+      type: "category",
+      name: "Processes",
+      level: 1,
+      properties: { description: "Actions, workflows, and procedures" },
+      confidence: 1,
+      tags: ["category", "processes"]
+    });
+    const relationNode = this.createNode({
+      id: "relations",
+      type: "category",
+      name: "Relations",
+      level: 1,
+      properties: { description: "Relationships and connections" },
+      confidence: 1,
+      tags: ["category", "relations"]
+    });
+    this.createRelationship({ from: rootNode.id, to: conceptNode.id, type: "contains", weight: 1 });
+    this.createRelationship({ from: rootNode.id, to: entityNode.id, type: "contains", weight: 1 });
+    this.createRelationship({ from: rootNode.id, to: processNode.id, type: "contains", weight: 1 });
+    this.createRelationship({ from: rootNode.id, to: relationNode.id, type: "contains", weight: 1 });
+    console.log("[KnowledgeGraph] Knowledge structures initialized with root nodes.");
+  }
+  initializeAgents() {
+    const agentTypes = [
+      "knowledge-curator",
+      "pattern-recognizer",
+      "relationship-builder",
+      "query-optimizer",
+      "learning-agent"
+    ];
+    for (const agentType of agentTypes) {
+      this.createAgent(agentType);
+    }
+    console.log(`[KnowledgeGraph] Initialized ${agentTypes.length} knowledge agents.`);
+  }
+  initializeChains() {
+    const chainTypes = [
+      "knowledge-acquisition",
+      "pattern-detection",
+      "relationship-inference",
+      "knowledge-optimization",
+      "learning-pipeline"
+    ];
+    for (const chainType of chainTypes) {
+      this.createChain(chainType);
+    }
+    console.log(`[KnowledgeGraph] Initialized ${chainTypes.length} knowledge chains.`);
+  }
+  initializeTools() {
+    const toolTypes = [
+      "knowledge-query",
+      "pattern-matcher",
+      "relationship-analyzer",
+      "graph-optimizer",
+      "learning-analyzer"
+    ];
+    for (const toolType of toolTypes) {
+      this.createTool(toolType);
+    }
+    console.log(`[KnowledgeGraph] Initialized ${toolTypes.length} knowledge tools.`);
+  }
+  // ── Node / Relationship / Agent / Chain / Tool Creation ─────────────────────
+  createNode(nodeData) {
+    const id = nodeData.id ?? `node-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    const node = {
+      id,
+      type: nodeData.type ?? "generic",
+      name: nodeData.name ?? id,
+      level: nodeData.level ?? 0,
+      properties: nodeData.properties ?? {},
+      metadata: {
+        created: Date.now(),
+        lastModified: Date.now(),
+        version: 1,
+        confidence: nodeData.confidence ?? 0.5
+      },
+      embeddings: nodeData.embeddings ?? [],
+      tags: nodeData.tags ?? []
+    };
+    if (this.nodes.size >= this.config.maxNodes) {
+      this.pruneNodes();
+    }
+    this.nodes.set(id, node);
+    this.metrics.totalNodes = this.nodes.size;
+    this.emit("nodeCreated", { node });
+    return node;
+  }
+  createRelationship(relData) {
+    const id = relData.id ?? `rel-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    const relationship = {
+      id,
+      from: relData.from,
+      to: relData.to,
+      type: relData.type ?? "related",
+      weight: relData.weight ?? 0.5,
+      properties: relData.properties ?? {},
+      metadata: {
+        created: Date.now(),
+        lastModified: Date.now(),
+        confidence: relData.confidence ?? 0.5
+      }
+    };
+    if (this.relationships.size >= this.config.maxRelationships) {
+      this.pruneRelationships();
+    }
+    this.relationships.set(id, relationship);
+    this.metrics.totalRelationships = this.relationships.size;
+    this.emit("relationshipCreated", { relationship });
+    return relationship;
+  }
+  createAgent(agentType) {
+    const id = `agent-${agentType}-${Date.now()}`;
+    const agent = {
+      id,
+      type: agentType,
+      capabilities: this.getAgentCapabilities(agentType),
+      state: "idle",
+      knowledge: /* @__PURE__ */ new Map(),
+      reasoning: this.createReasoningEngine(agentType),
+      tools: this.getAgentTools(agentType)
+    };
+    this.agents.set(id, agent);
+    this.emit("agentCreated", { agent });
+    return agent;
+  }
+  createChain(chainType) {
+    const id = `chain-${chainType}-${Date.now()}`;
+    const chain = {
+      id,
+      type: chainType,
+      steps: this.getChainSteps(chainType),
+      state: "idle",
+      executionHistory: [],
+      performance: {
+        totalExecutions: 0,
+        averageExecutionTime: 0,
+        successRate: 1
+      }
+    };
+    this.chains.set(id, chain);
+    this.emit("chainCreated", { chain });
+    return chain;
+  }
+  createTool(toolType) {
+    const id = `tool-${toolType}-${Date.now()}`;
+    const tool = {
+      id,
+      type: toolType,
+      capabilities: this.getToolCapabilities(toolType),
+      state: "ready",
+      usage: {
+        totalUses: 0,
+        lastUsed: null,
+        successRate: 1
+      }
+    };
+    this.tools.set(id, tool);
+    this.emit("toolCreated", { tool });
+    return tool;
+  }
+  // ── Querying ────────────────────────────────────────────────────────────────
+  async queryKnowledge(query, options = {}) {
+    this.metrics.knowledgeQueries++;
+    const queryType = options.type ?? "semantic";
+    const depth = options.depth ?? this.config.reasoningDepth;
+    try {
+      let results;
+      switch (queryType) {
+        case "semantic":
+          results = this.semanticQuery(query, depth);
+          break;
+        case "pattern":
+          results = this.patternQuery(query, depth);
+          break;
+        case "relationship":
+          results = this.relationshipQuery(query, depth);
+          break;
+        case "persona":
+          results = this.personaQuery(query, depth, options.persona);
+          break;
+        default:
+          results = this.semanticQuery(query, depth);
+      }
+      const reasonedResults = this.applyReasoning(results, query, depth);
+      this.emit("queryCompleted", { query, results: reasonedResults });
+      return {
+        success: true,
+        query,
+        results: reasonedResults,
+        metadata: {
+          type: queryType,
+          depth,
+          totalResults: reasonedResults.length,
+          queryTime: Date.now()
+        }
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`[KnowledgeGraph] Query failed: ${message}`);
+      return {
+        success: false,
+        query,
+        error: message
+      };
+    }
+  }
+  semanticQuery(query, depth) {
+    const results = [];
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [];
+    for (const [nodeId, node] of this.nodes) {
+      if (node.level === 0 || node.level === 1) {
+        queue.push({ nodeId, currentDepth: 0 });
+      }
+    }
+    while (queue.length > 0) {
+      const item = queue.shift();
+      if (!item) break;
+      const { nodeId, currentDepth } = item;
+      if (visited.has(nodeId) || currentDepth > depth) continue;
+      visited.add(nodeId);
+      const node = this.nodes.get(nodeId);
+      if (!node) continue;
+      if (this.matchesQuery(node, query)) {
+        const relevance = this.calculateRelevance(node, query);
+        results.push({
+          node,
+          relevance,
+          depth: currentDepth,
+          path: this.findPathToNode(nodeId)
+        });
+      }
+      const connected = this.getConnectedNodes(nodeId);
+      for (const connectedId of connected) {
+        if (!visited.has(connectedId)) {
+          queue.push({ nodeId: connectedId, currentDepth: currentDepth + 1 });
+        }
+      }
+    }
+    results.sort((a, b) => {
+      const aRel = a.relevance;
+      const bRel = b.relevance;
+      return bRel - aRel;
+    });
+    return results;
+  }
+  patternQuery(query, depth) {
+    const results = [];
+    for (const [patternKey, patterns] of this.knowledgePatterns) {
+      const lowerKey = patternKey.toLowerCase();
+      const lowerQuery = query.toLowerCase();
+      if (lowerKey.includes(lowerQuery) || lowerQuery.includes(lowerKey)) {
+        for (const pattern of patterns) {
+          results.push({
+            pattern,
+            patternKey,
+            relevance: this.calculateStringRelevance(patternKey, query),
+            depth: 0
+          });
+        }
+      }
+    }
+    for (const [, node] of this.nodes) {
+      if (node.tags.some((tag) => query.toLowerCase().includes(tag.toLowerCase()))) {
+        results.push({
+          node,
+          relevance: this.calculateRelevance(node, query),
+          depth: 0,
+          matchType: "tag-pattern"
+        });
+      }
+    }
+    results.sort((a, b) => {
+      const aRel = a.relevance;
+      const bRel = b.relevance;
+      return bRel - aRel;
+    });
+    return results.slice(0, depth * 10);
+  }
+  relationshipQuery(query, depth) {
+    const results = [];
+    for (const [, relationship] of this.relationships) {
+      const fromNode = this.nodes.get(relationship.from);
+      const toNode = this.nodes.get(relationship.to);
+      if (!fromNode || !toNode) continue;
+      const fromMatch = this.matchesQuery(fromNode, query);
+      const toMatch = this.matchesQuery(toNode, query);
+      if (fromMatch || toMatch) {
+        results.push({
+          relationship,
+          fromNode,
+          toNode,
+          relevance: (this.calculateRelevance(fromNode, query) + this.calculateRelevance(toNode, query)) / 2,
+          depth: 0
+        });
+      }
+    }
+    results.sort((a, b) => {
+      const aRel = a.relevance;
+      const bRel = b.relevance;
+      return bRel - aRel;
+    });
+    return results.slice(0, depth * 10);
+  }
+  personaQuery(query, depth, persona) {
+    const results = [];
+    if (persona && this.personaKnowledge.has(persona)) {
+      const pKnowledge = this.personaKnowledge.get(persona);
+      for (const [key, value] of pKnowledge) {
+        if (key.toLowerCase().includes(query.toLowerCase()) || query.toLowerCase().includes(key.toLowerCase())) {
+          results.push({
+            key,
+            value,
+            persona,
+            relevance: this.calculateStringRelevance(key, query),
+            depth: 0
+          });
+        }
+      }
+    } else {
+      for (const [personaId, pKnowledge] of this.personaKnowledge) {
+        for (const [key, value] of pKnowledge) {
+          if (key.toLowerCase().includes(query.toLowerCase()) || query.toLowerCase().includes(key.toLowerCase())) {
+            results.push({
+              key,
+              value,
+              persona: personaId,
+              relevance: this.calculateStringRelevance(key, query),
+              depth: 0
+            });
+          }
+        }
+      }
+    }
+    results.sort((a, b) => {
+      const aRel = a.relevance;
+      const bRel = b.relevance;
+      return bRel - aRel;
+    });
+    return results.slice(0, depth * 10);
+  }
+  // ── Reasoning ───────────────────────────────────────────────────────────────
+  applyReasoning(results, query, depth) {
+    this.metrics.reasoningOperations++;
+    if (results.length === 0) return results;
+    const filtered = results.filter((result) => {
+      const r = result;
+      const relevance = r.relevance ?? 0;
+      return relevance >= 1 - this.config.knowledgeRetention;
+    });
+    const weighted = filtered.map((result) => {
+      const r = result;
+      const d = r.depth ?? 0;
+      const relevance = r.relevance ?? 0;
+      const depthWeight = 1 / (1 + d * 0.1);
+      return {
+        ...r,
+        adjustedRelevance: relevance * depthWeight
+      };
+    });
+    weighted.sort((a, b) => {
+      return b.adjustedRelevance - a.adjustedRelevance;
+    });
+    const limited = weighted.slice(0, depth * 20);
+    this.emit("reasoningApplied", { query, inputCount: results.length, outputCount: limited.length });
+    return limited;
+  }
+  // ── Chain Execution ─────────────────────────────────────────────────────────
+  async executeChain(chain, input) {
+    const startTime = Date.now();
+    chain.state = "executing";
+    let currentInput = input;
+    try {
+      for (const step of chain.steps) {
+        currentInput = await this.executeStep(step, currentInput);
+      }
+      const executionTime = Date.now() - startTime;
+      chain.executionHistory.push({
+        input,
+        output: currentInput,
+        executionTime,
+        timestamp: Date.now()
+      });
+      chain.performance.totalExecutions++;
+      chain.performance.averageExecutionTime = (chain.performance.averageExecutionTime * (chain.performance.totalExecutions - 1) + executionTime) / chain.performance.totalExecutions;
+      chain.performance.successRate = (chain.performance.successRate * (chain.performance.totalExecutions - 1) + 1) / chain.performance.totalExecutions;
+      chain.state = "idle";
+      this.emit("chainExecuted", { chainId: chain.id, executionTime });
+      return currentInput;
+    } catch (error) {
+      chain.state = "error";
+      chain.performance.totalExecutions++;
+      chain.performance.successRate = chain.performance.successRate * (chain.performance.totalExecutions - 1) / chain.performance.totalExecutions;
+      const message = error instanceof Error ? error.message : String(error);
+      this.emit("chainError", { chainId: chain.id, error: message });
+      throw error;
+    }
+  }
+  async executeStep(step, input) {
+    const toolId = step.tool;
+    let tool;
+    for (const [, t] of this.tools) {
+      if (t.type === toolId || t.id === toolId) {
+        tool = t;
+        break;
+      }
+    }
+    if (!tool) {
+      console.log(`[KnowledgeGraph] Tool not found for step: ${toolId}, passing input through.`);
+      return input;
+    }
+    return this.executeTool(tool, step, input);
+  }
+  async executeTool(tool, step, input) {
+    tool.state = "executing";
+    tool.usage.totalUses++;
+    tool.usage.lastUsed = Date.now();
+    let result;
+    try {
+      switch (tool.type) {
+        case "knowledge-query":
+          result = this.executeKnowledgeQuery(input, step.parameters);
+          break;
+        case "pattern-matcher":
+          result = this.executePatternMatching(input, step.parameters);
+          break;
+        case "relationship-analyzer":
+          result = this.executeRelationshipBuilding(input, step.parameters);
+          break;
+        case "graph-optimizer":
+          result = this.executeOptimization(input, step.parameters);
+          break;
+        case "learning-analyzer":
+          result = this.executeLearningAnalysis(input, step.parameters);
+          break;
+        default:
+          result = input;
+      }
+      tool.state = "ready";
+      tool.usage.successRate = (tool.usage.successRate * (tool.usage.totalUses - 1) + 1) / tool.usage.totalUses;
+      this.emit("toolExecuted", { toolId: tool.id, toolType: tool.type });
+      return result;
+    } catch (error) {
+      tool.state = "error";
+      tool.usage.successRate = tool.usage.successRate * (tool.usage.totalUses - 1) / tool.usage.totalUses;
+      const message = error instanceof Error ? error.message : String(error);
+      this.emit("toolError", { toolId: tool.id, error: message });
+      throw error;
+    }
+  }
+  // ── Query Matching & Relevance ──────────────────────────────────────────────
+  matchesQuery(node, query) {
+    const lowerQuery = query.toLowerCase();
+    const lowerName = node.name.toLowerCase();
+    if (lowerName.includes(lowerQuery) || lowerQuery.includes(lowerName)) {
+      return true;
+    }
+    const description = node.properties.description ?? "";
+    if (description.toLowerCase().includes(lowerQuery)) {
+      return true;
+    }
+    for (const tag of node.tags) {
+      if (tag.toLowerCase().includes(lowerQuery) || lowerQuery.includes(tag.toLowerCase())) {
+        return true;
+      }
+    }
+    return false;
+  }
+  calculateRelevance(node, query) {
+    let relevance = 0;
+    const lowerQuery = query.toLowerCase();
+    const lowerName = node.name.toLowerCase();
+    if (lowerName === lowerQuery) {
+      relevance += 1;
+    } else if (lowerName.includes(lowerQuery)) {
+      relevance += 0.7;
+    } else if (lowerQuery.includes(lowerName)) {
+      relevance += 0.5;
+    }
+    const description = node.properties.description ?? "";
+    if (description.toLowerCase().includes(lowerQuery)) {
+      relevance += 0.3;
+    }
+    for (const tag of node.tags) {
+      if (tag.toLowerCase() === lowerQuery) {
+        relevance += 0.4;
+      } else if (tag.toLowerCase().includes(lowerQuery) || lowerQuery.includes(tag.toLowerCase())) {
+        relevance += 0.2;
+      }
+    }
+    relevance *= node.metadata.confidence;
+    return Math.min(1, Math.max(0, relevance));
+  }
+  calculateStringRelevance(str, query) {
+    const lowerStr = str.toLowerCase();
+    const lowerQuery = query.toLowerCase();
+    if (lowerStr === lowerQuery) return 1;
+    if (lowerStr.includes(lowerQuery)) return 0.7;
+    if (lowerQuery.includes(lowerStr)) return 0.5;
+    const strTokens = lowerStr.split(/\s+/);
+    const queryTokens = lowerQuery.split(/\s+/);
+    let overlapCount = 0;
+    for (const qt of queryTokens) {
+      if (strTokens.some((st) => st.includes(qt) || qt.includes(st))) {
+        overlapCount++;
+      }
+    }
+    return queryTokens.length > 0 ? overlapCount / queryTokens.length * 0.5 : 0;
+  }
+  // ── Graph Traversal ─────────────────────────────────────────────────────────
+  findPathToNode(nodeId) {
+    const path = [];
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [{ id: "root", trail: ["root"] }];
+    if (nodeId === "root") return ["root"];
+    while (queue.length > 0) {
+      const item = queue.shift();
+      if (!item) break;
+      const { id, trail } = item;
+      if (visited.has(id)) continue;
+      visited.add(id);
+      if (id === nodeId) {
+        return trail;
+      }
+      const connected = this.getConnectedNodes(id);
+      for (const connectedId of connected) {
+        if (!visited.has(connectedId)) {
+          queue.push({ id: connectedId, trail: [...trail, connectedId] });
+        }
+      }
+    }
+    return path.length > 0 ? path : [nodeId];
+  }
+  getConnectedNodes(nodeId) {
+    const connected = [];
+    for (const [, relationship] of this.relationships) {
+      if (relationship.from === nodeId) {
+        connected.push(relationship.to);
+      } else if (relationship.to === nodeId) {
+        connected.push(relationship.from);
+      }
+    }
+    return connected;
+  }
+  // ── Lookup Tables ───────────────────────────────────────────────────────────
+  getAgentCapabilities(agentType) {
+    const capabilities = {
+      "knowledge-curator": [
+        "knowledge-acquisition",
+        "knowledge-validation",
+        "knowledge-organization",
+        "knowledge-deduplication"
+      ],
+      "pattern-recognizer": [
+        "pattern-detection",
+        "pattern-classification",
+        "anomaly-detection",
+        "trend-analysis"
+      ],
+      "relationship-builder": [
+        "relationship-inference",
+        "relationship-validation",
+        "relationship-strengthening",
+        "relationship-pruning"
+      ],
+      "query-optimizer": [
+        "query-planning",
+        "query-caching",
+        "query-optimization",
+        "result-ranking"
+      ],
+      "learning-agent": [
+        "supervised-learning",
+        "unsupervised-learning",
+        "reinforcement-learning",
+        "transfer-learning"
+      ]
+    };
+    return capabilities[agentType] ?? ["generic-capability"];
+  }
+  createReasoningEngine(agentType) {
+    return {
+      type: agentType,
+      rules: this.getReasoningRules(agentType),
+      context: /* @__PURE__ */ new Map(),
+      history: []
+    };
+  }
+  getReasoningRules(agentType) {
+    const rules = {
+      "knowledge-curator": [
+        "validate-source-credibility",
+        "check-knowledge-consistency",
+        "merge-duplicate-knowledge",
+        "maintain-knowledge-hierarchy"
+      ],
+      "pattern-recognizer": [
+        "identify-recurring-patterns",
+        "classify-pattern-types",
+        "detect-anomalies",
+        "track-pattern-evolution"
+      ],
+      "relationship-builder": [
+        "infer-implicit-relationships",
+        "validate-relationship-consistency",
+        "strengthen-confirmed-relationships",
+        "prune-weak-relationships"
+      ],
+      "query-optimizer": [
+        "analyze-query-complexity",
+        "select-optimal-traversal",
+        "cache-frequent-queries",
+        "rank-results-by-relevance"
+      ],
+      "learning-agent": [
+        "extract-features",
+        "update-model-weights",
+        "evaluate-performance",
+        "adapt-learning-rate"
+      ]
+    };
+    return rules[agentType] ?? ["generic-rule"];
+  }
+  getAgentTools(agentType) {
+    const tools = {
+      "knowledge-curator": ["knowledge-query", "pattern-matcher"],
+      "pattern-recognizer": ["pattern-matcher", "learning-analyzer"],
+      "relationship-builder": ["relationship-analyzer", "knowledge-query"],
+      "query-optimizer": ["knowledge-query", "graph-optimizer"],
+      "learning-agent": ["learning-analyzer", "pattern-matcher"]
+    };
+    return tools[agentType] ?? ["knowledge-query"];
+  }
+  getChainSteps(chainType) {
+    const steps = {
+      "knowledge-acquisition": [
+        { tool: "knowledge-query", parameters: { action: "extract" } },
+        { tool: "pattern-matcher", parameters: { action: "validate" } },
+        { tool: "knowledge-query", parameters: { action: "store" } }
+      ],
+      "pattern-detection": [
+        { tool: "knowledge-query", parameters: { action: "gather" } },
+        { tool: "pattern-matcher", parameters: { action: "detect" } },
+        { tool: "learning-analyzer", parameters: { action: "classify" } }
+      ],
+      "relationship-inference": [
+        { tool: "knowledge-query", parameters: { action: "gather" } },
+        { tool: "relationship-analyzer", parameters: { action: "infer" } },
+        { tool: "relationship-analyzer", parameters: { action: "validate" } }
+      ],
+      "knowledge-optimization": [
+        { tool: "knowledge-query", parameters: { action: "analyze" } },
+        { tool: "graph-optimizer", parameters: { action: "optimize" } },
+        { tool: "graph-optimizer", parameters: { action: "verify" } }
+      ],
+      "learning-pipeline": [
+        { tool: "knowledge-query", parameters: { action: "extract" } },
+        { tool: "learning-analyzer", parameters: { action: "learn" } },
+        { tool: "learning-analyzer", parameters: { action: "evaluate" } }
+      ]
+    };
+    return steps[chainType] ?? [{ tool: "knowledge-query", parameters: { action: "default" } }];
+  }
+  getToolCapabilities(toolType) {
+    const capabilities = {
+      "knowledge-query": [
+        "semantic-search",
+        "pattern-search",
+        "relationship-search",
+        "full-text-search"
+      ],
+      "pattern-matcher": [
+        "exact-match",
+        "fuzzy-match",
+        "regex-match",
+        "semantic-match"
+      ],
+      "relationship-analyzer": [
+        "path-finding",
+        "cluster-detection",
+        "centrality-analysis",
+        "community-detection"
+      ],
+      "graph-optimizer": [
+        "node-pruning",
+        "relationship-pruning",
+        "index-optimization",
+        "cache-optimization"
+      ],
+      "learning-analyzer": [
+        "feature-extraction",
+        "model-training",
+        "performance-evaluation",
+        "prediction"
+      ]
+    };
+    return capabilities[toolType] ?? ["generic-capability"];
+  }
+  // ── Tool Execution Implementations ──────────────────────────────────────────
+  executeKnowledgeQuery(input, parameters) {
+    console.log(`[KnowledgeGraph] Executing knowledge query with action: ${parameters.action}`);
+    return input;
+  }
+  executePatternMatching(input, parameters) {
+    console.log(`[KnowledgeGraph] Executing pattern matching with action: ${parameters.action}`);
+    return input;
+  }
+  executeRelationshipBuilding(input, parameters) {
+    console.log(`[KnowledgeGraph] Executing relationship building with action: ${parameters.action}`);
+    return input;
+  }
+  executeOptimization(input, parameters) {
+    console.log(`[KnowledgeGraph] Executing optimization with action: ${parameters.action}`);
+    return input;
+  }
+  executeLearningAnalysis(input, parameters) {
+    console.log(`[KnowledgeGraph] Executing learning analysis with action: ${parameters.action}`);
+    return input;
+  }
+  // ── Pruning ─────────────────────────────────────────────────────────────────
+  pruneNodes() {
+    const threshold = 1 - this.config.knowledgeRetention;
+    const toRemove = [];
+    for (const [nodeId, node] of this.nodes) {
+      if (node.metadata.confidence < threshold && node.type !== "root" && node.type !== "category") {
+        toRemove.push(nodeId);
+      }
+    }
+    toRemove.sort((a, b) => {
+      const aConf = this.nodes.get(a)?.metadata.confidence ?? 0;
+      const bConf = this.nodes.get(b)?.metadata.confidence ?? 0;
+      return aConf - bConf;
+    });
+    const removeCount = Math.min(toRemove.length, Math.floor(this.config.maxNodes * 0.1));
+    for (let i = 0; i < removeCount; i++) {
+      this.nodes.delete(toRemove[i]);
+      for (const [relId, rel] of this.relationships) {
+        if (rel.from === toRemove[i] || rel.to === toRemove[i]) {
+          this.relationships.delete(relId);
+        }
+      }
+    }
+    this.metrics.totalNodes = this.nodes.size;
+    this.metrics.totalRelationships = this.relationships.size;
+    console.log(`[KnowledgeGraph] Pruned ${removeCount} low-confidence nodes.`);
+  }
+  pruneRelationships() {
+    const toRemove = [];
+    for (const [relId, rel] of this.relationships) {
+      if (rel.metadata.confidence < 1 - this.config.knowledgeRetention) {
+        toRemove.push(relId);
+      }
+    }
+    toRemove.sort((a, b) => {
+      const aConf = this.relationships.get(a)?.metadata.confidence ?? 0;
+      const bConf = this.relationships.get(b)?.metadata.confidence ?? 0;
+      return aConf - bConf;
+    });
+    const removeCount = Math.min(toRemove.length, Math.floor(this.config.maxRelationships * 0.1));
+    for (let i = 0; i < removeCount; i++) {
+      this.relationships.delete(toRemove[i]);
+    }
+    this.metrics.totalRelationships = this.relationships.size;
+    console.log(`[KnowledgeGraph] Pruned ${removeCount} weak relationships.`);
+  }
+  // ── Status & Optimization ──────────────────────────────────────────────────
+  getStatus() {
+    return {
+      config: this.config,
+      metrics: { ...this.metrics },
+      nodes: {
+        total: this.nodes.size,
+        byType: this.getNodeCountsByType()
+      },
+      relationships: {
+        total: this.relationships.size,
+        byType: this.getRelationshipCountsByType()
+      },
+      agents: {
+        total: this.agents.size,
+        byState: this.getAgentCountsByState()
+      },
+      chains: {
+        total: this.chains.size,
+        byState: this.getChainCountsByState()
+      },
+      tools: {
+        total: this.tools.size,
+        byState: this.getToolCountsByState()
+      },
+      personaKnowledge: {
+        totalPersonas: this.personaKnowledge.size
+      },
+      knowledgePatterns: {
+        totalPatterns: this.knowledgePatterns.size
+      }
+    };
+  }
+  getNodeCountsByType() {
+    const counts = {};
+    for (const [, node] of this.nodes) {
+      counts[node.type] = (counts[node.type] ?? 0) + 1;
+    }
+    return counts;
+  }
+  getRelationshipCountsByType() {
+    const counts = {};
+    for (const [, rel] of this.relationships) {
+      counts[rel.type] = (counts[rel.type] ?? 0) + 1;
+    }
+    return counts;
+  }
+  getAgentCountsByState() {
+    const counts = {};
+    for (const [, agent] of this.agents) {
+      counts[agent.state] = (counts[agent.state] ?? 0) + 1;
+    }
+    return counts;
+  }
+  getChainCountsByState() {
+    const counts = {};
+    for (const [, chain] of this.chains) {
+      counts[chain.state] = (counts[chain.state] ?? 0) + 1;
+    }
+    return counts;
+  }
+  getToolCountsByState() {
+    const counts = {};
+    for (const [, tool] of this.tools) {
+      counts[tool.state] = (counts[tool.state] ?? 0) + 1;
+    }
+    return counts;
+  }
+  async optimize() {
+    console.log("[KnowledgeGraph] Starting knowledge graph optimization...");
+    const nodeThreshold = 1 - this.config.knowledgeRetention;
+    const nodesToRemove = [];
+    for (const [nodeId, node] of this.nodes) {
+      if (node.metadata.confidence < nodeThreshold && node.type !== "root" && node.type !== "category") {
+        nodesToRemove.push(nodeId);
+      }
+    }
+    for (const nodeId of nodesToRemove) {
+      this.nodes.delete(nodeId);
+    }
+    const relsToRemove = [];
+    for (const [relId, rel] of this.relationships) {
+      if (rel.metadata.confidence < nodeThreshold) {
+        relsToRemove.push(relId);
+      }
+      if (!this.nodes.has(rel.from) || !this.nodes.has(rel.to)) {
+        relsToRemove.push(relId);
+      }
+    }
+    for (const relId of relsToRemove) {
+      this.relationships.delete(relId);
+    }
+    this.metrics.totalNodes = this.nodes.size;
+    this.metrics.totalRelationships = this.relationships.size;
+    this.metrics.lastOptimization = Date.now();
+    console.log(
+      `[KnowledgeGraph] Optimization complete. Removed ${nodesToRemove.length} nodes and ${relsToRemove.length} relationships.`
+    );
+    this.emit("optimized", {
+      removedNodes: nodesToRemove.length,
+      removedRelationships: relsToRemove.length,
+      metrics: this.metrics
+    });
+  }
+  // ── Persona Knowledge ──────────────────────────────────────────────────────
+  addPersonaKnowledge(personaId, key, value) {
+    if (!this.personaKnowledge.has(personaId)) {
+      this.personaKnowledge.set(personaId, /* @__PURE__ */ new Map());
+    }
+    this.personaKnowledge.get(personaId).set(key, value);
+    this.emit("personaKnowledgeAdded", { personaId, key });
+  }
+  getPersonaKnowledge(personaId) {
+    return this.personaKnowledge.get(personaId);
+  }
+  // ── Knowledge Pattern Management ───────────────────────────────────────────
+  addKnowledgePattern(patternKey, pattern) {
+    if (!this.knowledgePatterns.has(patternKey)) {
+      this.knowledgePatterns.set(patternKey, []);
+    }
+    this.knowledgePatterns.get(patternKey).push(pattern);
+    this.emit("patternAdded", { patternKey });
+  }
+  getKnowledgePatterns(patternKey) {
+    return this.knowledgePatterns.get(patternKey);
+  }
+  // ── Node & Relationship Accessors ──────────────────────────────────────────
+  getNode(nodeId) {
+    return this.nodes.get(nodeId);
+  }
+  getRelationship(relId) {
+    return this.relationships.get(relId);
+  }
+  getAllNodes() {
+    return Array.from(this.nodes.values());
+  }
+  getAllRelationships() {
+    return Array.from(this.relationships.values());
+  }
+  getNodesByType(type) {
+    const result = [];
+    for (const [, node] of this.nodes) {
+      if (node.type === type) {
+        result.push(node);
+      }
+    }
+    return result;
+  }
+  getRelationshipsByType(type) {
+    const result = [];
+    for (const [, rel] of this.relationships) {
+      if (rel.type === type) {
+        result.push(rel);
+      }
+    }
+    return result;
+  }
+  updateNode(nodeId, updates) {
+    const node = this.nodes.get(nodeId);
+    if (!node) return void 0;
+    if (updates.name !== void 0) node.name = updates.name;
+    if (updates.type !== void 0) node.type = updates.type;
+    if (updates.level !== void 0) node.level = updates.level;
+    if (updates.properties !== void 0) node.properties = { ...node.properties, ...updates.properties };
+    if (updates.tags !== void 0) node.tags = updates.tags;
+    if (updates.embeddings !== void 0) node.embeddings = updates.embeddings;
+    node.metadata.lastModified = Date.now();
+    node.metadata.version++;
+    this.emit("nodeUpdated", { node });
+    return node;
+  }
+  updateRelationship(relId, updates) {
+    const rel = this.relationships.get(relId);
+    if (!rel) return void 0;
+    if (updates.type !== void 0) rel.type = updates.type;
+    if (updates.weight !== void 0) rel.weight = updates.weight;
+    if (updates.properties !== void 0) rel.properties = { ...rel.properties, ...updates.properties };
+    rel.metadata.lastModified = Date.now();
+    this.emit("relationshipUpdated", { relationship: rel });
+    return rel;
+  }
+  deleteNode(nodeId) {
+    if (!this.nodes.has(nodeId)) return false;
+    this.nodes.delete(nodeId);
+    const relsToRemove = [];
+    for (const [relId, rel] of this.relationships) {
+      if (rel.from === nodeId || rel.to === nodeId) {
+        relsToRemove.push(relId);
+      }
+    }
+    for (const relId of relsToRemove) {
+      this.relationships.delete(relId);
+    }
+    this.metrics.totalNodes = this.nodes.size;
+    this.metrics.totalRelationships = this.relationships.size;
+    this.emit("nodeDeleted", { nodeId, removedRelationships: relsToRemove.length });
+    return true;
+  }
+  deleteRelationship(relId) {
+    if (!this.relationships.has(relId)) return false;
+    this.relationships.delete(relId);
+    this.metrics.totalRelationships = this.relationships.size;
+    this.emit("relationshipDeleted", { relId });
+    return true;
+  }
+  getMetrics() {
+    return { ...this.metrics };
+  }
+};
+
+// src/knowledge/vector-store.ts
+var ChromaVectorStore = class {
+  config;
+  client;
+  collection;
+  isInitialized;
+  metrics;
+  queryCache;
+  cacheMaxAge;
+  constructor(config = {}) {
+    this.config = {
+      host: config.host ?? "localhost",
+      port: config.port ?? 8e3,
+      collectionName: config.collectionName ?? "baseline-vectors",
+      embeddingFunction: config.embeddingFunction ?? "default",
+      metadata: config.metadata ?? {}
+    };
+    this.client = null;
+    this.collection = null;
+    this.isInitialized = false;
+    this.metrics = {
+      totalDocuments: 0,
+      totalQueries: 0,
+      averageQueryTime: 0,
+      lastOptimization: Date.now()
+    };
+    this.queryCache = /* @__PURE__ */ new Map();
+    this.cacheMaxAge = 5 * 60 * 1e3;
+  }
+  // ── Initialization ──────────────────────────────────────────────────────────
+  async initializeClient() {
+    if (this.isInitialized) {
+      console.log("[VectorStore] Client already initialized.");
+      return;
+    }
+    try {
+      let chromadb;
+      try {
+        chromadb = await import("chromadb");
+      } catch {
+        console.log("[VectorStore] chromadb package not found. Install it with: npm install chromadb");
+        console.log("[VectorStore] Running in fallback mode without vector storage.");
+        this.isInitialized = false;
+        return;
+      }
+      const ChromaClient = chromadb.ChromaClient;
+      this.client = new ChromaClient({
+        path: `http://${this.config.host}:${this.config.port}`
+      });
+      await this.initializeCollection();
+      this.isInitialized = true;
+      console.log(`[VectorStore] Client initialized. Connected to ${this.config.host}:${this.config.port}.`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`[VectorStore] Failed to initialize client: ${message}`);
+      console.log("[VectorStore] Running in fallback mode without vector storage.");
+      this.isInitialized = false;
+    }
+  }
+  async initializeCollection() {
+    if (!this.client) {
+      throw new Error("Client not initialized");
+    }
+    try {
+      const client = this.client;
+      const embeddingFunction = this.createEmbeddingFunction();
+      this.collection = await client.getOrCreateCollection({
+        name: this.config.collectionName,
+        metadata: this.config.metadata,
+        embeddingFunction
+      });
+      console.log(`[VectorStore] Collection "${this.config.collectionName}" ready.`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`[VectorStore] Failed to initialize collection: ${message}`);
+      throw error;
+    }
+  }
+  // ── Document Operations ─────────────────────────────────────────────────────
+  async addDocuments(input) {
+    if (!this.isInitialized || !this.collection) {
+      return {
+        success: false,
+        error: "Vector store not initialized. Call initializeClient() first."
+      };
+    }
+    try {
+      const collection = this.collection;
+      const addPayload = {
+        ids: input.ids,
+        documents: input.documents
+      };
+      if (input.embeddings) {
+        addPayload.embeddings = input.embeddings;
+      }
+      if (input.metadatas) {
+        addPayload.metadatas = input.metadatas;
+      }
+      await collection.add(addPayload);
+      this.metrics.totalDocuments += input.ids.length;
+      console.log(`[VectorStore] Added ${input.ids.length} documents.`);
+      return {
+        success: true,
+        metadata: {
+          addedCount: input.ids.length,
+          totalDocuments: this.metrics.totalDocuments
+        }
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`[VectorStore] Failed to add documents: ${message}`);
+      return {
+        success: false,
+        error: message
+      };
+    }
+  }
+  async query(queryText, options = {}) {
+    if (!this.isInitialized || !this.collection) {
+      return {
+        success: false,
+        query: queryText,
+        error: "Vector store not initialized. Call initializeClient() first."
+      };
+    }
+    const startTime = Date.now();
+    const cacheKey = `${queryText}:${JSON.stringify(options)}`;
+    const cached = this.queryCache.get(cacheKey);
+    if (cached && Date.now() - cached.timestamp < this.cacheMaxAge) {
+      this.metrics.totalQueries++;
+      return {
+        success: true,
+        query: queryText,
+        results: cached.result,
+        metadata: { fromCache: true, queryTime: 0 }
+      };
+    }
+    try {
+      const collection = this.collection;
+      const queryPayload = {
+        queryTexts: [queryText],
+        nResults: options.nResults ?? 10
+      };
+      if (options.where) {
+        queryPayload.where = options.where;
+      }
+      if (options.whereDocument) {
+        queryPayload.whereDocument = options.whereDocument;
+      }
+      if (options.include) {
+        queryPayload.include = options.include;
+      }
+      const results = await collection.query(queryPayload);
+      const queryTime = Date.now() - startTime;
+      this.metrics.totalQueries++;
+      this.metrics.averageQueryTime = (this.metrics.averageQueryTime * (this.metrics.totalQueries - 1) + queryTime) / this.metrics.totalQueries;
+      this.queryCache.set(cacheKey, { result: results, timestamp: Date.now() });
+      return {
+        success: true,
+        query: queryText,
+        results,
+        metadata: {
+          queryTime,
+          nResults: options.nResults ?? 10,
+          fromCache: false
+        }
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`[VectorStore] Query failed: ${message}`);
+      return {
+        success: false,
+        query: queryText,
+        error: message
+      };
+    }
+  }
+  async semanticSearch(queryText, nResults = 10) {
+    return this.query(queryText, {
+      nResults,
+      include: ["documents", "metadatas", "distances"]
+    });
+  }
+  async filterSearch(queryText, options = {}) {
+    return this.query(queryText, {
+      nResults: options.nResults ?? 10,
+      where: options.where,
+      whereDocument: options.whereDocument,
+      include: options.include ?? ["documents", "metadatas", "distances"]
+    });
+  }
+  async fullTextSearch(searchText, nResults = 10) {
+    return this.query(searchText, {
+      nResults,
+      whereDocument: { $contains: searchText },
+      include: ["documents", "metadatas", "distances"]
+    });
+  }
+  async regexSearch(pattern, nResults = 10) {
+    if (!this.isInitialized || !this.collection) {
+      return {
+        success: false,
+        query: pattern,
+        error: "Vector store not initialized. Call initializeClient() first."
+      };
+    }
+    try {
+      const collection = this.collection;
+      const allResults = await collection.get({
+        include: ["documents", "metadatas"]
+      });
+      const resultsObj = allResults;
+      const ids = resultsObj.ids ?? [];
+      const documents = resultsObj.documents ?? [];
+      const metadatas = resultsObj.metadatas ?? [];
+      const regex = new RegExp(pattern, "i");
+      const matchedIds = [];
+      const matchedDocuments = [];
+      const matchedMetadatas = [];
+      for (let i = 0; i < ids.length; i++) {
+        const doc = documents[i];
+        if (doc && regex.test(doc)) {
+          matchedIds.push(ids[i]);
+          matchedDocuments.push(doc);
+          matchedMetadatas.push(metadatas[i] ?? {});
+          if (matchedIds.length >= nResults) break;
+        }
+      }
+      return {
+        success: true,
+        query: pattern,
+        results: {
+          ids: [matchedIds],
+          documents: [matchedDocuments],
+          metadatas: [matchedMetadatas]
+        },
+        metadata: {
+          matchCount: matchedIds.length,
+          searchType: "regex"
+        }
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`[VectorStore] Regex search failed: ${message}`);
+      return {
+        success: false,
+        query: pattern,
+        error: message
+      };
+    }
+  }
+  async updateDocuments(input) {
+    if (!this.isInitialized || !this.collection) {
+      return {
+        success: false,
+        error: "Vector store not initialized. Call initializeClient() first."
+      };
+    }
+    try {
+      const collection = this.collection;
+      const updatePayload = {
+        ids: input.ids,
+        documents: input.documents
+      };
+      if (input.embeddings) {
+        updatePayload.embeddings = input.embeddings;
+      }
+      if (input.metadatas) {
+        updatePayload.metadatas = input.metadatas;
+      }
+      await collection.update(updatePayload);
+      this.queryCache.clear();
+      console.log(`[VectorStore] Updated ${input.ids.length} documents.`);
+      return {
+        success: true,
+        metadata: {
+          updatedCount: input.ids.length
+        }
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`[VectorStore] Failed to update documents: ${message}`);
+      return {
+        success: false,
+        error: message
+      };
+    }
+  }
+  async deleteDocuments(ids) {
+    if (!this.isInitialized || !this.collection) {
+      return {
+        success: false,
+        error: "Vector store not initialized. Call initializeClient() first."
+      };
+    }
+    try {
+      const collection = this.collection;
+      await collection.delete({ ids });
+      this.metrics.totalDocuments = Math.max(0, this.metrics.totalDocuments - ids.length);
+      this.queryCache.clear();
+      console.log(`[VectorStore] Deleted ${ids.length} documents.`);
+      return {
+        success: true,
+        metadata: {
+          deletedCount: ids.length,
+          totalDocuments: this.metrics.totalDocuments
+        }
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`[VectorStore] Failed to delete documents: ${message}`);
+      return {
+        success: false,
+        error: message
+      };
+    }
+  }
+  // ── Collection Management ───────────────────────────────────────────────────
+  async getCollectionStats() {
+    if (!this.isInitialized || !this.collection) {
+      console.log("[VectorStore] Not initialized, cannot get collection stats.");
+      return null;
+    }
+    try {
+      const collection = this.collection;
+      const count = await collection.count();
+      const peek = await collection.peek({ limit: 1 });
+      this.metrics.totalDocuments = count;
+      return {
+        name: this.config.collectionName,
+        count,
+        metadata: {
+          ...this.config.metadata,
+          peekSample: peek
+        }
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`[VectorStore] Failed to get collection stats: ${message}`);
+      return null;
+    }
+  }
+  async optimizeCollection() {
+    if (!this.isInitialized || !this.collection) {
+      return {
+        success: false,
+        error: "Vector store not initialized. Call initializeClient() first."
+      };
+    }
+    console.log("[VectorStore] Starting collection optimization...");
+    try {
+      const cacheSize = this.queryCache.size;
+      this.queryCache.clear();
+      this.metrics.lastOptimization = Date.now();
+      const stats = await this.getCollectionStats();
+      console.log(`[VectorStore] Optimization complete. Cache cleared (${cacheSize} entries).`);
+      return {
+        success: true,
+        metadata: {
+          cacheEntriesCleared: cacheSize,
+          collectionStats: stats,
+          optimizationTime: Date.now()
+        }
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`[VectorStore] Optimization failed: ${message}`);
+      return {
+        success: false,
+        error: message
+      };
+    }
+  }
+  // ── Embedding Function ──────────────────────────────────────────────────────
+  createEmbeddingFunction() {
+    const funcType = this.config.embeddingFunction;
+    switch (funcType) {
+      case "openai": {
+        console.log("[VectorStore] Using OpenAI embedding function.");
+        return {
+          generate: async (texts) => {
+            return texts.map((_text) => {
+              const embedding = [];
+              for (let i = 0; i < 1536; i++) {
+                embedding.push(Math.random() * 2 - 1);
+              }
+              return embedding;
+            });
+          }
+        };
+      }
+      case "cohere": {
+        console.log("[VectorStore] Using Cohere embedding function.");
+        return {
+          generate: async (texts) => {
+            return texts.map((_text) => {
+              const embedding = [];
+              for (let i = 0; i < 768; i++) {
+                embedding.push(Math.random() * 2 - 1);
+              }
+              return embedding;
+            });
+          }
+        };
+      }
+      case "huggingface": {
+        console.log("[VectorStore] Using HuggingFace embedding function.");
+        return {
+          generate: async (texts) => {
+            return texts.map((_text) => {
+              const embedding = [];
+              for (let i = 0; i < 384; i++) {
+                embedding.push(Math.random() * 2 - 1);
+              }
+              return embedding;
+            });
+          }
+        };
+      }
+      case "default":
+      default: {
+        console.log("[VectorStore] Using default embedding function.");
+        return {
+          generate: async (texts) => {
+            return texts.map((text) => {
+              const embedding = [];
+              for (let i = 0; i < 384; i++) {
+                let hash = 0;
+                for (let j = 0; j < text.length; j++) {
+                  hash = (hash << 5) - hash + text.charCodeAt(j) + i | 0;
+                }
+                embedding.push(hash % 1e3 / 1e3);
+              }
+              return embedding;
+            });
+          }
+        };
+      }
+    }
+  }
+  // ── Batch Operations ────────────────────────────────────────────────────────
+  async batchOperation(operations) {
+    if (!this.isInitialized || !this.collection) {
+      return {
+        success: false,
+        error: "Vector store not initialized. Call initializeClient() first."
+      };
+    }
+    const results = [];
+    let successCount = 0;
+    let failureCount = 0;
+    for (const operation of operations) {
+      try {
+        switch (operation.type) {
+          case "add": {
+            const addResult = await this.addDocuments(operation.data);
+            results.push({ type: "add", success: addResult.success, error: addResult.error });
+            if (addResult.success) successCount++;
+            else failureCount++;
+            break;
+          }
+          case "update": {
+            const updateResult = await this.updateDocuments(operation.data);
+            results.push({ type: "update", success: updateResult.success, error: updateResult.error });
+            if (updateResult.success) successCount++;
+            else failureCount++;
+            break;
+          }
+          case "delete": {
+            const ids = operation.data.ids;
+            const deleteResult = await this.deleteDocuments(ids);
+            results.push({ type: "delete", success: deleteResult.success, error: deleteResult.error });
+            if (deleteResult.success) successCount++;
+            else failureCount++;
+            break;
+          }
+          default:
+            results.push({ type: operation.type, success: false, error: `Unknown operation type: ${operation.type}` });
+            failureCount++;
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        results.push({ type: operation.type, success: false, error: message });
+        failureCount++;
+      }
+    }
+    console.log(`[VectorStore] Batch operation complete: ${successCount} succeeded, ${failureCount} failed.`);
+    return {
+      success: failureCount === 0,
+      metadata: {
+        totalOperations: operations.length,
+        successCount,
+        failureCount,
+        results
+      }
+    };
+  }
+  // ── Client Status ───────────────────────────────────────────────────────────
+  getClientStatus() {
+    return {
+      isInitialized: this.isInitialized,
+      config: {
+        host: this.config.host,
+        port: this.config.port,
+        collectionName: this.config.collectionName,
+        embeddingFunction: this.config.embeddingFunction
+      },
+      metrics: { ...this.metrics },
+      cache: {
+        entries: this.queryCache.size,
+        maxAge: this.cacheMaxAge
+      },
+      hasClient: this.client !== null,
+      hasCollection: this.collection !== null
+    };
+  }
+  // ── Cleanup ─────────────────────────────────────────────────────────────────
+  async close() {
+    console.log("[VectorStore] Closing vector store connection...");
+    this.queryCache.clear();
+    this.client = null;
+    this.collection = null;
+    this.isInitialized = false;
+    console.log("[VectorStore] Vector store connection closed.");
+  }
+  // ── Utility Accessors ──────────────────────────────────────────────────────
+  getMetrics() {
+    return { ...this.metrics };
+  }
+  isReady() {
+    return this.isInitialized;
+  }
+  getCollectionName() {
+    return this.config.collectionName;
+  }
+  clearCache() {
+    this.queryCache.clear();
+    console.log("[VectorStore] Query cache cleared.");
+  }
+};
+
+// src/index.ts
+var BaselineLangCore = class {
+  lexicon;
+  parser;
+  lang;
+  constructor() {
+    this.lexicon = new BaselineLexicon();
+    this.parser = new BaselineParser();
+    this.lang = new BaselineLang(this.parser, this.lexicon);
+  }
+  async initialize() {
+    await this.lexicon.initialize();
+    await this.parser.initialize();
+    await this.lang.initialize();
+  }
+  getLang() {
+    return this.lang;
+  }
+  getParser() {
+    return this.parser;
+  }
+  getLexicon() {
+    return this.lexicon;
+  }
+};
+export {
+  BaselineLang,
+  BaselineLangCore,
+  BaselineLexicon,
+  BaselineParser,
+  ChromaVectorStore,
+  GrammarValidator,
+  KnowledgeGraphEngine,
+  baselineGrammar,
+  baselineGrammarRules
+};
+/**
+ * Baseline Lang -- Core Language Implementation
+ * The Language & Expression Layer of Baseline Stack
+ *
+ * @license Apache-2.0
+ */
+/**
+ * Baseline Language Parser
+ * PEG-based parser for Baseline Language syntax
+ *
+ * @license Apache-2.0
+ */
+/**
+ * Baseline Language Lexicon Management
+ * Domain-specific vocabulary and template system
+ *
+ * @license Apache-2.0
+ */
+/**
+ * Baseline Language PEG Grammar
+ * Parsing Expression Grammar for the Baseline prompt engineering language
+ *
+ * @license Apache-2.0
+ */
+/**
+ * Baseline Lang -- Main Entry Point
+ * The Language & Expression Layer of Baseline Stack
+ *
+ * @license Apache-2.0
+ */