@baselineos/protocol-core 1.0.0

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@baselineos/protocol-core",
+  "version": "1.0.0",
+  "description": "Baseline Protocol™ — Open-source AI governance specification",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^2.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "dev": "tsup src/index.ts --format esm --dts --watch",
+    "test": "vitest run",
+    "lint": "eslint src/",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  }
+}

package/src/__tests__/functional.test.ts

@@ -0,0 +1,269 @@
+/**
+ * Functional tests for @baselineos/protocol-core v1.0
+ * Tests actual behavior of lang, parser, lexicon, and grammar validator.
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import {
+  BaselineLangCore,
+  BaselineLang,
+  BaselineParser,
+  BaselineLexicon,
+  GrammarValidator,
+  baselineGrammar,
+  baselineGrammarRules,
+  KnowledgeGraphEngine,
+  ChromaVectorStore,
+} from '../index.js';
+
+// ─── BaselineLangCore ────────────────────────────────────────────────────────
+
+describe('BaselineLangCore', () => {
+  it('initializes all subsystems', async () => {
+    const core = new BaselineLangCore();
+    await core.initialize();
+
+    expect(core.getLang()).toBeInstanceOf(BaselineLang);
+    expect(core.getParser()).toBeInstanceOf(BaselineParser);
+    expect(core.getLexicon()).toBeInstanceOf(BaselineLexicon);
+  });
+});
+
+// ─── BaselineParser ──────────────────────────────────────────────────────────
+
+describe('BaselineParser', () => {
+  let parser: BaselineParser;
+
+  beforeEach(async () => {
+    parser = new BaselineParser();
+    await parser.initialize();
+  });
+
+  it('tokenizes identifiers', () => {
+    const tokens = parser.tokenize('hello world');
+    expect(tokens.length).toBeGreaterThanOrEqual(2);
+    expect(tokens.some(t => t.type === 'IDENTIFIER')).toBe(true);
+  });
+
+  it('tokenizes strings', () => {
+    const tokens = parser.tokenize('"hello world"');
+    expect(tokens.some(t => t.type === 'STRING')).toBe(true);
+  });
+
+  it('tokenizes numbers', () => {
+    const tokens = parser.tokenize('42 3.14');
+    expect(tokens.filter(t => t.type === 'NUMBER')).toHaveLength(2);
+  });
+
+  it('includes EOF token', () => {
+    const tokens = parser.tokenize('test');
+    expect(tokens[tokens.length - 1]?.type).toBe('EOF');
+  });
+
+  it('parses a simple program', async () => {
+    const program = await parser.parse('lang { name: "test" }');
+    expect(program).toBeDefined();
+    expect(program.blocks).toBeDefined();
+  });
+
+  it('parses empty input', async () => {
+    const program = await parser.parse('');
+    expect(program).toBeDefined();
+    expect(program.blocks).toHaveLength(0);
+  });
+});
+
+// ─── BaselineLexicon ─────────────────────────────────────────────────────────
+
+describe('BaselineLexicon', () => {
+  let lexicon: BaselineLexicon;
+
+  beforeEach(async () => {
+    lexicon = new BaselineLexicon();
+    await lexicon.initialize();
+  });
+
+  it('loads default domain packs', () => {
+    const domains = lexicon.listDomains();
+    expect(domains.length).toBeGreaterThan(0);
+  });
+
+  it('retrieves a domain by name', () => {
+    const domains = lexicon.listDomains();
+    if (domains.length > 0) {
+      const name = domains[0]!.name;
+      const domain = lexicon.getDomain(name);
+      expect(domain).toBeDefined();
+      expect(domain?.name).toBe(name);
+    }
+  });
+
+  it('adds a custom domain', () => {
+    const countBefore = lexicon.listDomains().length;
+    lexicon.addDomain({
+      name: 'test-domain',
+      description: 'Test domain for v1.0 tests',
+      version: '1.0.0',
+      terms: [],
+    });
+    expect(lexicon.listDomains().length).toBe(countBefore + 1);
+    expect(lexicon.getDomain('test-domain')).toBeDefined();
+  });
+
+  it('adds and retrieves vocabulary', () => {
+    lexicon.addDomain({ name: 'vocab-test', description: 'Test', version: '1.0.0', terms: [] });
+    lexicon.addVocabulary('vocab-test', {
+      domain: 'vocab-test',
+      terms: [{ term: 'governance', definition: 'Rules and controls' }],
+    });
+    const vocab = lexicon.getVocabulary('vocab-test');
+    expect(vocab).toBeDefined();
+  });
+
+  it('adds and retrieves templates', () => {
+    lexicon.addTemplate({
+      name: 'test-template',
+      description: 'A test template',
+      template: 'Hello {{name}}',
+      variables: [{ name: 'name', type: 'string', description: 'Name' }],
+    });
+    expect(lexicon.getTemplate('test-template')).toBeDefined();
+    expect(lexicon.listTemplates().some(t => t.name === 'test-template')).toBe(true);
+  });
+
+  it('adds and retrieves patterns', () => {
+    lexicon.addPattern({
+      name: 'test-pattern',
+      description: 'A test pattern',
+      pattern: /test/,
+      examples: ['test input'],
+    });
+    expect(lexicon.getPattern('test-pattern')).toBeDefined();
+    expect(lexicon.listPatterns().some(p => p.name === 'test-pattern')).toBe(true);
+  });
+
+  it('searches vocabulary', () => {
+    const results = lexicon.searchVocabulary('governance');
+    expect(Array.isArray(results)).toBe(true);
+  });
+
+  it('returns lexicon stats', () => {
+    const stats = lexicon.getLexiconStats();
+    expect(stats.totalDomains).toBeGreaterThanOrEqual(0);
+    expect(typeof stats.totalTerms).toBe('number');
+    expect(typeof stats.totalTemplates).toBe('number');
+    expect(typeof stats.totalPatterns).toBe('number');
+  });
+});
+
+// ─── BaselineLang ────────────────────────────────────────────────────────────
+
+describe('BaselineLang', () => {
+  let lang: BaselineLang;
+
+  beforeEach(async () => {
+    const core = new BaselineLangCore();
+    await core.initialize();
+    lang = core.getLang();
+  });
+
+  it('generates from template', async () => {
+    const result = await lang.generateFromTemplate('Hello {{name}}!', { name: 'Baseline' });
+    expect(result).toContain('Baseline');
+  });
+
+  it('returns language stats', async () => {
+    const stats = await lang.getLanguageStats();
+    expect(stats).toBeDefined();
+    expect(typeof stats.lexiconSize).toBe('number');
+  });
+
+  it('validates a parsed program', async () => {
+    const parser = new BaselineParser();
+    const program = await parser.parse('');
+    const result = await lang.validate(program);
+    expect(result).toBeDefined();
+    expect(Array.isArray(result.errors)).toBe(true);
+  });
+});
+
+// ─── GrammarValidator ────────────────────────────────────────────────────────
+
+describe('GrammarValidator', () => {
+  it('validates balanced brackets', () => {
+    expect(GrammarValidator.validateRule('(a / b) c')).toBe(true);
+    expect(GrammarValidator.validateRule('(a (b c)')).toBe(false);
+  });
+
+  it('validates balanced braces', () => {
+    expect(GrammarValidator.validateRule('{ a }')).toBe(true);
+    expect(GrammarValidator.validateRule('{ a')).toBe(false);
+  });
+
+  it('extracts referenced rules', () => {
+    const refs = GrammarValidator.extractReferencedRules('Program = lang frame core');
+    expect(Array.isArray(refs)).toBe(true);
+  });
+
+  it('generates grammar summary', () => {
+    const summary = GrammarValidator.generateSummary(baselineGrammarRules);
+    expect(summary.totalRules).toBeGreaterThan(0);
+    expect(summary.validationStatus).toBeDefined();
+  });
+
+  it('grammar has substantial rules', () => {
+    const ruleCount = Object.keys(baselineGrammarRules).length;
+    expect(ruleCount).toBeGreaterThanOrEqual(10);
+  });
+
+  it('grammar rules record is populated', () => {
+    expect(Object.keys(baselineGrammarRules).length).toBeGreaterThan(0);
+  });
+});
+
+// ─── KnowledgeGraphEngine ────────────────────────────────────────────────────
+
+describe('KnowledgeGraphEngine', () => {
+  it('creates and retrieves nodes', () => {
+    const engine = new KnowledgeGraphEngine();
+    engine.createNode({
+      id: 'node-1',
+      type: 'concept',
+      name: 'Governance',
+      properties: { domain: 'baseline' },
+    });
+    const node = engine.getNode('node-1');
+    expect(node).toBeDefined();
+    expect(node?.name).toBe('Governance');
+  });
+
+  it('creates relationships between nodes', () => {
+    const engine = new KnowledgeGraphEngine();
+    engine.createNode({ id: 'a', type: 'concept', name: 'A', properties: {} });
+    engine.createNode({ id: 'b', type: 'concept', name: 'B', properties: {} });
+    engine.createRelationship({
+      id: 'rel-1',
+      from: 'a',
+      to: 'b',
+      type: 'relates_to',
+      properties: {},
+    });
+    const rels = engine.getAllRelationships();
+    expect(rels.length).toBeGreaterThanOrEqual(1);
+  });
+});
+
+// ─── ChromaVectorStore ───────────────────────────────────────────────────────
+
+describe('ChromaVectorStore', () => {
+  it('reports not ready before initialization', () => {
+    const store = new ChromaVectorStore();
+    expect(store.isReady()).toBe(false);
+  });
+
+  it('returns metrics', () => {
+    const store = new ChromaVectorStore();
+    const metrics = store.getMetrics();
+    expect(metrics).toBeDefined();
+    expect(typeof metrics.totalDocuments).toBe('number');
+  });
+});

package/src/__tests__/smoke.test.ts

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import { BaselineLangCore, KnowledgeGraphEngine, ChromaVectorStore } from '../index.js';
+
+describe('protocol-core', () => {
+  it('should instantiate BaselineLangCore', () => {
+    const core = new BaselineLangCore();
+    expect(core).toBeDefined();
+    expect(core.getLang()).toBeDefined();
+    expect(core.getParser()).toBeDefined();
+    expect(core.getLexicon()).toBeDefined();
+  });
+
+  it('should instantiate KnowledgeGraphEngine', () => {
+    const engine = new KnowledgeGraphEngine();
+    expect(engine).toBeDefined();
+  });
+
+  it('should instantiate ChromaVectorStore', () => {
+    const store = new ChromaVectorStore();
+    expect(store).toBeDefined();
+    expect(store.isReady()).toBe(false);
+  });
+});

package/src/chromadb.d.ts

@@ -0,0 +1,9 @@
+// chromadb is an optional peer dependency loaded via dynamic import().
+// This declaration satisfies the TypeScript compiler (TS2307).
+// The runtime code casts everything to `unknown` anyway.
+declare module 'chromadb' {
+  export class ChromaClient {
+    constructor(config?: Record<string, unknown>);
+    getOrCreateCollection(options: Record<string, unknown>): Promise<unknown>;
+  }
+}

package/src/index.ts

@@ -0,0 +1,117 @@
+/**
+ * Baseline Lang -- Main Entry Point
+ * The Language & Expression Layer of Baseline Stack
+ *
+ * @license Apache-2.0
+ */
+
+import { BaselineLang } from './lang/lang.js';
+import { BaselineParser } from './parser/parser.js';
+import { BaselineLexicon } from './lexicon/lexicon.js';
+
+// ─── Core Orchestrator ──────────────────────────────────────────────
+
+export class BaselineLangCore {
+  private lexicon: BaselineLexicon;
+  private parser: BaselineParser;
+  private lang: BaselineLang;
+
+  constructor() {
+    this.lexicon = new BaselineLexicon();
+    this.parser = new BaselineParser();
+    this.lang = new BaselineLang(this.parser, this.lexicon);
+  }
+
+  async initialize(): Promise<void> {
+    await this.lexicon.initialize();
+    await this.parser.initialize();
+    await this.lang.initialize();
+  }
+
+  getLang(): BaselineLang {
+    return this.lang;
+  }
+
+  getParser(): BaselineParser {
+    return this.parser;
+  }
+
+  getLexicon(): BaselineLexicon {
+    return this.lexicon;
+  }
+}
+
+// ─── Exports ────────────────────────────────────────────────────────
+
+// Classes
+export { BaselineLang } from './lang/lang.js';
+export { BaselineParser } from './parser/parser.js';
+export { BaselineLexicon } from './lexicon/lexicon.js';
+
+// Types
+export type * from './types/index.js';
+
+// Grammar
+export { baselineGrammarRules, baselineGrammar, GrammarValidator } from './parser/grammar.js';
+
+// Lang types
+export type {
+  ValidationResult,
+  ExecutionResult,
+  IntermediateRepresentation,
+  LanguageStats,
+} from './lang/lang.js';
+
+// Parser types
+export type {
+  Token,
+  TokenType,
+  ParsedBlock,
+  LangBlockContent,
+  FrameBlockContent,
+  CoreBlockContent,
+} from './parser/parser.js';
+
+// Lexicon types
+export type {
+  LexiconDomain,
+  LexiconTerm,
+  LexiconVocabulary,
+  LexiconDefinition,
+  LexiconTemplate,
+  LexiconVariable,
+  LexiconPattern,
+  SearchResult,
+  LexiconStats,
+} from './lexicon/lexicon.js';
+
+// Knowledge Graph
+export { KnowledgeGraphEngine } from './knowledge/knowledge-graph.js';
+
+export type {
+  KnowledgeNode,
+  KnowledgeRelationship,
+  KnowledgeAgent,
+  ReasoningEngine,
+  KnowledgeChain,
+  ChainStep,
+  ChainExecution,
+  KnowledgeTool,
+  QueryResult,
+  KnowledgeGraphConfig,
+  KnowledgeGraphMetrics,
+} from './knowledge/knowledge-graph.js';
+
+// Vector Store
+export { ChromaVectorStore } from './knowledge/vector-store.js';
+
+export type {
+  VectorStoreConfig,
+  VectorStoreMetrics,
+  DocumentInput,
+  VectorQueryResult,
+  VectorQueryOptions,
+  FilterSearchOptions,
+  BatchOperation,
+  CollectionStats,
+} from './knowledge/vector-store.js';