meta-log-db
Version:
Native database package for Meta-Log (ProLog, DataLog, R5RS)
255 lines • 7.22 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.MetaLogDb = void 0;
const engine_js_1 = require("./prolog/engine.js");
const engine_js_2 = require("./datalog/engine.js");
const registry_js_1 = require("./r5rs/registry.js");
const parser_js_1 = require("./jsonl/parser.js");
const triple_store_js_1 = require("./rdf/triple-store.js");
const validator_js_1 = require("./shacl/validator.js");
const index_js_1 = require("./extensions/homology/index.js");
/**
* Meta-Log Database - Main class
*/
class MetaLogDb {
constructor(config = {}) {
this.config = {
enableProlog: true,
enableDatalog: true,
enableRdf: true,
enableShacl: true,
...config
};
this.jsonl = new parser_js_1.JsonlParser();
if (this.config.enableProlog) {
this.prolog = new engine_js_1.PrologEngine();
}
if (this.config.enableDatalog) {
this.datalog = new engine_js_2.DatalogEngine();
}
if (this.config.enableRdf) {
this.rdf = new triple_store_js_1.TripleStore();
}
if (this.config.enableShacl) {
this.shacl = new validator_js_1.ShaclValidator();
}
if (this.config.r5rsEnginePath) {
this.loadR5RSEngine(this.config.r5rsEnginePath);
}
}
/**
* Load R5RS engine from file
*/
async loadR5RSEngine(path) {
this.r5rs = new registry_js_1.R5RSRegistry(path);
await this.r5rs.load(path);
}
/**
* Load canvas file (JSONL or CanvasL)
*/
async loadCanvas(path) {
let canvas;
if (path.endsWith('.canvasl')) {
canvas = await this.jsonl.parseCanvasL(path);
}
else {
canvas = await this.jsonl.parse(path);
}
const facts = this.jsonl.extractFacts(canvas);
if (this.prolog) {
this.prolog.addFacts(facts);
}
if (this.datalog) {
this.datalog.addFacts(facts);
}
if (this.rdf) {
const triples = this.jsonl.toRdf(facts);
this.rdf.addTriples(triples);
}
}
/**
* Parse JSONL canvas
*/
async parseJsonlCanvas(path) {
return await this.jsonl.parse(path);
}
/**
* Parse CanvasL file
*/
async parseCanvasL(path) {
return await this.jsonl.parseCanvasL(path);
}
/**
* Extract facts from canvas
*/
extractFactsFromCanvas(canvas) {
return this.jsonl.extractFacts(canvas);
}
/**
* Extract facts
*/
extractFacts() {
return this.jsonl.getFacts();
}
/**
* Convert JSONL facts to RDF
*/
jsonlToRdf(facts) {
return this.jsonl.toRdf(facts);
}
/**
* Execute ProLog query
*/
async prologQuery(query) {
if (!this.prolog) {
throw new Error('ProLog engine not enabled');
}
return await this.prolog.query(query);
}
/**
* Build ProLog database from facts
*/
buildPrologDb(facts) {
if (!this.prolog) {
throw new Error('ProLog engine not enabled');
}
this.prolog.buildDb(facts);
}
/**
* Add ProLog rule
*/
addPrologRule(rule) {
if (!this.prolog) {
throw new Error('ProLog engine not enabled');
}
// Parse rule string into PrologRule format
const match = rule.match(/^(.+?)\s*:-\s*(.+)$/);
if (match) {
const head = match[1].trim();
const body = match[2].split(',').map(b => b.trim());
this.prolog.addRule({ head, body });
}
}
/**
* Execute DataLog query
*/
async datalogQuery(query, program) {
if (!this.datalog) {
throw new Error('DataLog engine not enabled');
}
return await this.datalog.query(query, program);
}
/**
* Build DataLog program
*/
buildDatalogProgram(rules) {
if (!this.datalog) {
throw new Error('DataLog engine not enabled');
}
const parsedRules = rules.map(rule => {
const match = rule.match(/^(.+?)\s*:-\s*(.+)$/);
if (match) {
return {
head: match[1].trim(),
body: match[2].split(',').map(b => b.trim())
};
}
throw new Error(`Invalid rule format: ${rule}`);
});
return this.datalog.buildProgram(parsedRules);
}
/**
* Execute SPARQL query
*/
async sparqlQuery(query) {
if (!this.rdf) {
throw new Error('RDF engine not enabled');
}
return await this.rdf.sparql(query);
}
/**
* Store RDF triples
*/
storeTriples(triples) {
if (!this.rdf) {
throw new Error('RDF engine not enabled');
}
this.rdf.addTriples(triples);
}
/**
* RDFS entailment
*/
rdfsEntailment(triples) {
if (!this.rdf) {
throw new Error('RDF engine not enabled');
}
return this.rdf.rdfsEntailment(triples);
}
/**
* Load SHACL shapes
*/
async loadShaclShapes(path) {
if (!this.shacl) {
throw new Error('SHACL validator not enabled');
}
return await this.shacl.loadShapes(path);
}
/**
* Validate SHACL
*/
async validateShacl(shapes, triples) {
if (!this.shacl) {
throw new Error('SHACL validator not enabled');
}
const targetTriples = triples || (this.rdf ? this.rdf.getTriples() : []);
return await this.shacl.validate(shapes || {}, targetTriples);
}
/**
* Execute R5RS function
*/
async executeR5RS(functionName, args) {
if (!this.r5rs) {
throw new Error('R5RS engine not loaded');
}
return await this.r5rs.execute(functionName, args);
}
/**
* Register R5RS function
*/
registerR5RSFunction(name, fn) {
if (!this.r5rs) {
this.r5rs = new registry_js_1.R5RSRegistry();
}
this.r5rs.register(name, fn);
}
/**
* Get configuration
*/
getConfig() {
return { ...this.config };
}
/**
* Validate homology of chain complex
* Requires enableHomology: true in config
*/
validateHomology(complex) {
if (!this.config.enableHomology) {
throw new Error('Homology extension not enabled. Set enableHomology: true in config');
}
const validator = new index_js_1.HomologyValidator(complex);
return validator.validate();
}
/**
* Compute Betti number for dimension n
* Requires enableHomology: true in config
*/
computeBetti(complex, n) {
if (!this.config.enableHomology) {
throw new Error('Homology extension not enabled. Set enableHomology: true in config');
}
const validator = new index_js_1.HomologyValidator(complex);
return validator.computeBetti(n);
}
}
exports.MetaLogDb = MetaLogDb;
//# sourceMappingURL=database.js.map