trellis 2.0.13 → 2.1.2

package/src/core/plugins/types.ts

@@ -1,126 +0,0 @@
-/**
- * Plugin System Types
- *
- * Defines the plugin interface, manifest format, lifecycle hooks,
- * and event system for extensibility.
- *
- * @module trellis/core/plugins
- */
-
-import type { KernelMiddleware } from '../kernel/middleware.js';
-import type { OntologySchema } from '../ontology/types.js';
-import type { DatalogRule } from '../query/types.js';
-import type { KernelOp } from '../persist/backend.js';
-
-// ---------------------------------------------------------------------------
-// Plugin definition
-// ---------------------------------------------------------------------------
-
-export interface PluginDef {
-  /** Unique plugin identifier (e.g. "trellis:security", "my-org:custom"). */
-  id: string;
-  /** Human-readable name. */
-  name: string;
-  /** Semantic version. */
-  version: string;
-  /** Description. */
-  description?: string;
-  /** Plugin dependencies (other plugin IDs). */
-  dependencies?: string[];
-
-  /** Kernel middleware provided by this plugin. */
-  middleware?: KernelMiddleware[];
-  /** Ontology schemas provided by this plugin. */
-  ontologies?: OntologySchema[];
-  /** Datalog rules provided by this plugin. */
-  rules?: DatalogRule[];
-  /** Event listeners provided by this plugin. */
-  eventHandlers?: EventHandler[];
-
-  /** Called when the plugin is loaded. */
-  onLoad?: (ctx: PluginContext) => void | Promise<void>;
-  /** Called when the plugin is unloaded. */
-  onUnload?: (ctx: PluginContext) => void | Promise<void>;
-}
-
-// ---------------------------------------------------------------------------
-// Plugin context — what the plugin receives during lifecycle
-// ---------------------------------------------------------------------------
-
-export interface PluginContext {
-  /** The plugin's own ID. */
-  pluginId: string;
-  /** Subscribe to events. */
-  on: (event: string, handler: EventCallback) => void;
-  /** Emit an event. */
-  emit: (event: string, data?: unknown) => void;
-  /** Get workspace config value. */
-  getConfig: (key: string) => unknown;
-  /** Log a message. */
-  log: (message: string) => void;
-}
-
-// ---------------------------------------------------------------------------
-// Event system
-// ---------------------------------------------------------------------------
-
-export type EventCallback = (data: unknown) => void | Promise<void>;
-
-export interface EventHandler {
-  /** Event name pattern (e.g. "op:*", "entity:created", "milestone:created"). */
-  event: string;
-  /** Handler function. */
-  handler: EventCallback;
-}
-
-/** Well-known event names. */
-export type WellKnownEvent =
-  | 'op:applied'
-  | 'entity:created'
-  | 'entity:updated'
-  | 'entity:deleted'
-  | 'link:added'
-  | 'link:removed'
-  | 'milestone:created'
-  | 'issue:created'
-  | 'issue:closed'
-  | 'plugin:loaded'
-  | 'plugin:unloaded';
-
-// ---------------------------------------------------------------------------
-// Workspace configuration
-// ---------------------------------------------------------------------------
-
-export interface WorkspaceConfig {
-  /** Active ontology IDs. */
-  ontologies?: string[];
-  /** Active plugin IDs. */
-  plugins?: string[];
-  /** Tracked file patterns (globs). */
-  trackedPaths?: string[];
-  /** Ignore patterns. */
-  ignorePaths?: string[];
-  /** Branch policies. */
-  branchPolicies?: Record<string, { linear?: boolean }>;
-  /** Embedding model override. */
-  embeddingModel?: string;
-  /** Snapshot threshold (ops between auto-snapshots). */
-  snapshotThreshold?: number;
-  /** Custom key-value settings. */
-  settings?: Record<string, unknown>;
-}
-
-// ---------------------------------------------------------------------------
-// Plugin manifest (for on-disk .trellis/plugins.json)
-// ---------------------------------------------------------------------------
-
-export interface PluginManifest {
-  /** Plugin ID. */
-  id: string;
-  /** Installed version. */
-  version: string;
-  /** Whether the plugin is enabled. */
-  enabled: boolean;
-  /** Plugin-specific configuration. */
-  config?: Record<string, unknown>;
-}

package/src/core/query/datalog.ts

@@ -1,188 +0,0 @@
-/**
- * Datalog Evaluator — Rule-based recursive queries.
- *
- * Provides transitive closure, reachability, and other recursive
- * graph queries via Datalog-style rules evaluated over the EAV store.
- *
- * Built-in rules:
- *   - `reachable(?src, ?tgt)` via a named link attribute
- *   - `ancestor(?x, ?y)` (generic transitive closure over any link)
- *
- * Custom rules can be registered via `addRule()`.
- *
- * @module trellis/core/query
- */
-
-import type { EAVStore } from '../store/eav-store.js';
-import type { DatalogRule } from './types.js';
-import { variable, literal } from './types.js';
-import { QueryEngine } from './engine.js';
-
-// ---------------------------------------------------------------------------
-// Built-in rule constructors
-// ---------------------------------------------------------------------------
-
-/**
- * Creates a transitive closure rule over a specific link attribute.
- *
- * `reachable(?x, ?y) :- (x attr y)`
- * `reachable(?x, ?y) :- (x attr ?z), reachable(?z, ?y)`
- */
-export function transitiveClosureRules(ruleName: string, linkAttribute: string): DatalogRule[] {
-  return [
-    // Base case: direct link
-    {
-      name: ruleName,
-      params: ['x', 'y'],
-      body: [
-        {
-          kind: 'link',
-          source: variable('x'),
-          attribute: literal(linkAttribute),
-          target: variable('y'),
-        },
-      ],
-      filters: [],
-    },
-    // Recursive case: indirect via intermediate
-    {
-      name: ruleName,
-      params: ['x', 'y'],
-      body: [
-        {
-          kind: 'link',
-          source: variable('x'),
-          attribute: literal(linkAttribute),
-          target: variable('z'),
-        },
-        {
-          kind: 'rule',
-          name: ruleName,
-          args: [variable('z'), variable('y')],
-        },
-      ],
-      filters: [],
-    },
-  ];
-}
-
-/**
- * Creates a reverse reachability rule (follows links backwards).
- */
-export function reverseReachabilityRules(ruleName: string, linkAttribute: string): DatalogRule[] {
-  return [
-    {
-      name: ruleName,
-      params: ['x', 'y'],
-      body: [
-        {
-          kind: 'link',
-          source: variable('y'),
-          attribute: literal(linkAttribute),
-          target: variable('x'),
-        },
-      ],
-      filters: [],
-    },
-    {
-      name: ruleName,
-      params: ['x', 'y'],
-      body: [
-        {
-          kind: 'link',
-          source: variable('z'),
-          attribute: literal(linkAttribute),
-          target: variable('x'),
-        },
-        {
-          kind: 'rule',
-          name: ruleName,
-          args: [variable('z'), variable('y')],
-        },
-      ],
-      filters: [],
-    },
-  ];
-}
-
-/**
- * Creates a "sibling" rule — entities that share a common parent via a link attribute.
- *
- * `sibling(?a, ?b) :- (?a attr ?parent), (?b attr ?parent)`
- * FILTER ?a != ?b
- */
-export function siblingRules(ruleName: string, linkAttribute: string): DatalogRule[] {
-  return [
-    {
-      name: ruleName,
-      params: ['a', 'b'],
-      body: [
-        {
-          kind: 'link',
-          source: variable('a'),
-          attribute: literal(linkAttribute),
-          target: variable('parent'),
-        },
-        {
-          kind: 'link',
-          source: variable('b'),
-          attribute: literal(linkAttribute),
-          target: variable('parent'),
-        },
-      ],
-      filters: [
-        {
-          kind: 'filter',
-          left: variable('a'),
-          op: '!=',
-          right: variable('b'),
-        },
-      ],
-    },
-  ];
-}
-
-// ---------------------------------------------------------------------------
-// Datalog Runtime — convenience wrapper around QueryEngine + rules
-// ---------------------------------------------------------------------------
-
-export class DatalogRuntime {
-  private engine: QueryEngine;
-
-  constructor(store: EAVStore) {
-    this.engine = new QueryEngine(store);
-  }
-
-  /** Register a Datalog rule (or multiple). */
-  addRule(rule: DatalogRule): void {
-    this.engine.addRule(rule);
-  }
-
-  addRules(rules: DatalogRule[]): void {
-    for (const r of rules) this.engine.addRule(r);
-  }
-
-  removeRule(name: string): void {
-    this.engine.removeRule(name);
-  }
-
-  /** Register built-in transitive closure for a link attribute. */
-  registerTransitiveClosure(ruleName: string, linkAttribute: string): void {
-    this.addRules(transitiveClosureRules(ruleName, linkAttribute));
-  }
-
-  /** Register built-in reverse reachability for a link attribute. */
-  registerReverseReachability(ruleName: string, linkAttribute: string): void {
-    this.addRules(reverseReachabilityRules(ruleName, linkAttribute));
-  }
-
-  /** Register built-in sibling rule for a link attribute. */
-  registerSiblings(ruleName: string, linkAttribute: string): void {
-    this.addRules(siblingRules(ruleName, linkAttribute));
-  }
-
-  /** Get the underlying QueryEngine for direct query execution. */
-  getEngine(): QueryEngine {
-    return this.engine;
-  }
-}

package/src/core/query/engine.ts

@@ -1,370 +0,0 @@
-/**
- * EQL-S Query Engine — Pattern-matching evaluator over the EAV store.
- *
- * Evaluates queries by matching fact/link patterns against the store,
- * binding variables, applying filters, and computing aggregates.
- *
- * @module trellis/core/query
- */
-
-import type { EAVStore, Fact, Link, Atom } from '../store/eav-store.js';
-import type {
-  Query, Pattern, FactPattern, LinkPattern, NotPattern, OrPattern,
-  RuleApplication, Filter, FilterOp, Aggregate, OrderBy,
-  Term, Bindings, DatalogRule,
-} from './types.js';
-import { isVariable, isLiteral } from './types.js';
-
-// ---------------------------------------------------------------------------
-// Result type
-// ---------------------------------------------------------------------------
-
-export interface QueryResult {
-  bindings: Record<string, Atom>[];
-  executionTime: number;
-  count: number;
-}
-
-// ---------------------------------------------------------------------------
-// Engine
-// ---------------------------------------------------------------------------
-
-export class QueryEngine {
-  private rules: Map<string, DatalogRule[]> = new Map();
-  private maxRuleDepth = 32;
-
-  constructor(private store: EAVStore) {}
-
-  /** Register a Datalog rule. Multiple rules with the same name = union. */
-  addRule(rule: DatalogRule): void {
-    const existing = this.rules.get(rule.name) ?? [];
-    existing.push(rule);
-    this.rules.set(rule.name, existing);
-  }
-
-  removeRule(name: string): void {
-    this.rules.delete(name);
-  }
-
-  /** Execute a query against the store. */
-  execute(query: Query): QueryResult {
-    const start = performance.now();
-
-    // Evaluate patterns
-    let results = this._evaluatePatterns(query.where, [new Map()]);
-
-    // Apply filters
-    for (const filter of query.filters) {
-      results = results.filter((b) => this._evalFilter(filter, b));
-    }
-
-    // Apply aggregates
-    if (query.aggregates.length > 0) {
-      results = this._aggregate(results, query.aggregates, query.select);
-    }
-
-    // Apply ordering
-    if (query.orderBy.length > 0) {
-      results = this._order(results, query.orderBy);
-    }
-
-    // Apply offset/limit
-    if (query.offset > 0) results = results.slice(query.offset);
-    if (query.limit > 0) results = results.slice(0, query.limit);
-
-    // Project selected variables
-    const projected = this._project(results, query.select);
-
-    return {
-      bindings: projected,
-      executionTime: performance.now() - start,
-      count: projected.length,
-    };
-  }
-
-  // -------------------------------------------------------------------------
-  // Pattern evaluation
-  // -------------------------------------------------------------------------
-
-  private _evaluatePatterns(patterns: Pattern[], bindings: Bindings[]): Bindings[] {
-    let current = bindings;
-    for (const pattern of patterns) {
-      if (current.length === 0) break;
-      current = this._evaluatePattern(pattern, current);
-    }
-    return current;
-  }
-
-  private _evaluatePattern(pattern: Pattern, bindings: Bindings[]): Bindings[] {
-    switch (pattern.kind) {
-      case 'fact': return this._evalFactPattern(pattern, bindings);
-      case 'link': return this._evalLinkPattern(pattern, bindings);
-      case 'not': return this._evalNotPattern(pattern, bindings);
-      case 'or': return this._evalOrPattern(pattern, bindings);
-      case 'rule': return this._evalRuleApplication(pattern, bindings);
-    }
-  }
-
-  private _evalFactPattern(p: FactPattern, bindings: Bindings[]): Bindings[] {
-    const results: Bindings[] = [];
-    for (const b of bindings) {
-      const eResolved = this._resolve(p.entity, b);
-      const aResolved = this._resolve(p.attribute, b);
-      const vResolved = this._resolve(p.value, b);
-
-      let facts: Fact[];
-      if (eResolved !== undefined && aResolved !== undefined) {
-        facts = this.store.getFactsByEntity(String(eResolved))
-          .filter((f) => f.a === aResolved);
-      } else if (eResolved !== undefined) {
-        facts = this.store.getFactsByEntity(String(eResolved));
-      } else if (aResolved !== undefined && vResolved !== undefined) {
-        facts = this.store.getFactsByValue(String(aResolved), vResolved);
-      } else if (aResolved !== undefined) {
-        facts = this.store.getFactsByAttribute(String(aResolved));
-      } else {
-        facts = this.store.getAllFacts();
-      }
-
-      if (vResolved !== undefined) {
-        facts = facts.filter((f) => f.v === vResolved);
-      }
-
-      for (const fact of facts) {
-        const nb = new Map(b);
-        if (this._bind(p.entity, fact.e, nb) &&
-            this._bind(p.attribute, fact.a, nb) &&
-            this._bind(p.value, fact.v, nb)) {
-          results.push(nb);
-        }
-      }
-    }
-    return results;
-  }
-
-  private _evalLinkPattern(p: LinkPattern, bindings: Bindings[]): Bindings[] {
-    const results: Bindings[] = [];
-    for (const b of bindings) {
-      const srcResolved = this._resolve(p.source, b);
-      const attrResolved = this._resolve(p.attribute, b);
-      const tgtResolved = this._resolve(p.target, b);
-
-      let links: Link[];
-      if (srcResolved !== undefined && attrResolved !== undefined) {
-        links = this.store.getLinksByEntityAndAttribute(String(srcResolved), String(attrResolved));
-      } else if (srcResolved !== undefined) {
-        links = this.store.getLinksByEntity(String(srcResolved));
-      } else if (attrResolved !== undefined) {
-        links = this.store.getLinksByAttribute(String(attrResolved));
-      } else {
-        links = this.store.getAllLinks();
-      }
-
-      if (tgtResolved !== undefined) {
-        links = links.filter((l) => l.e2 === tgtResolved);
-      }
-
-      for (const link of links) {
-        const nb = new Map(b);
-        if (this._bind(p.source, link.e1, nb) &&
-            this._bind(p.attribute, link.a, nb) &&
-            this._bind(p.target, link.e2, nb)) {
-          results.push(nb);
-        }
-      }
-    }
-    return results;
-  }
-
-  private _evalNotPattern(p: NotPattern, bindings: Bindings[]): Bindings[] {
-    return bindings.filter((b) => {
-      const matches = this._evaluatePattern(p.pattern, [b]);
-      return matches.length === 0;
-    });
-  }
-
-  private _evalOrPattern(p: OrPattern, bindings: Bindings[]): Bindings[] {
-    const results: Bindings[] = [];
-    for (const branch of p.branches) {
-      const branchResults = this._evaluatePatterns(branch, bindings);
-      results.push(...branchResults);
-    }
-    return this._dedup(results);
-  }
-
-  private _evalRuleApplication(p: RuleApplication, bindings: Bindings[], depth = 0): Bindings[] {
-    if (depth > this.maxRuleDepth) return [];
-    const ruleDefs = this.rules.get(p.name);
-    if (!ruleDefs) return [];
-
-    const results: Bindings[] = [];
-    for (const b of bindings) {
-      for (const rule of ruleDefs) {
-        // Bind rule params from application args
-        const ruleBindings = new Map(b);
-        let ok = true;
-        for (let i = 0; i < rule.params.length && i < p.args.length; i++) {
-          const resolved = this._resolve(p.args[i], b);
-          if (resolved !== undefined) {
-            ruleBindings.set(rule.params[i], resolved);
-          } else if (isVariable(p.args[i])) {
-            // Leave unbound — will be bound by body
-          }
-        }
-        if (!ok) continue;
-
-        // Evaluate body
-        let bodyResults = this._evaluatePatterns(rule.body, [ruleBindings]);
-
-        // Apply rule filters
-        for (const f of rule.filters) {
-          bodyResults = bodyResults.filter((rb) => this._evalFilter(f, rb));
-        }
-
-        // Map back rule param bindings to the application arg variables
-        for (const rb of bodyResults) {
-          const nb = new Map(b);
-          for (let i = 0; i < rule.params.length && i < p.args.length; i++) {
-            if (isVariable(p.args[i])) {
-              const val = rb.get(rule.params[i]);
-              if (val !== undefined) nb.set(p.args[i].name, val);
-            }
-          }
-          results.push(nb);
-        }
-      }
-    }
-    return this._dedup(results);
-  }
-
-  // -------------------------------------------------------------------------
-  // Filtering
-  // -------------------------------------------------------------------------
-
-  private _evalFilter(filter: Filter, b: Bindings): boolean {
-    const left = this._resolve(filter.left, b);
-    const right = this._resolve(filter.right, b);
-    if (left === undefined || right === undefined) return false;
-
-    switch (filter.op) {
-      case '=': return left === right;
-      case '!=': return left !== right;
-      case '<': return (left as any) < (right as any);
-      case '<=': return (left as any) <= (right as any);
-      case '>': return (left as any) > (right as any);
-      case '>=': return (left as any) >= (right as any);
-      case 'contains': return String(left).includes(String(right));
-      case 'startsWith': return String(left).startsWith(String(right));
-      case 'endsWith': return String(left).endsWith(String(right));
-      case 'matches': return new RegExp(String(right)).test(String(left));
-      default: return false;
-    }
-  }
-
-  // -------------------------------------------------------------------------
-  // Aggregation
-  // -------------------------------------------------------------------------
-
-  private _aggregate(bindings: Bindings[], aggregates: Aggregate[], groupBy: string[]): Bindings[] {
-    // Group by non-aggregated select variables
-    const aggVarNames = new Set(aggregates.map((a) => a.as));
-    const groupVars = groupBy.filter((v) => !aggVarNames.has(v));
-
-    const groups = new Map<string, Bindings[]>();
-    for (const b of bindings) {
-      const key = groupVars.map((v) => String(b.get(v) ?? '')).join('\0');
-      const group = groups.get(key) ?? [];
-      group.push(b);
-      groups.set(key, group);
-    }
-
-    const results: Bindings[] = [];
-    for (const [, group] of groups) {
-      const nb = new Map(group[0]);
-      for (const agg of aggregates) {
-        const vals = group.map((b) => b.get(agg.variable)).filter((v) => v !== undefined);
-        nb.set(agg.as, this._computeAggregate(agg.op, vals as Atom[]));
-      }
-      results.push(nb);
-    }
-    return results;
-  }
-
-  private _computeAggregate(op: string, vals: Atom[]): Atom {
-    switch (op) {
-      case 'count': return vals.length;
-      case 'sum': return vals.reduce((s, v) => (s as number) + (Number(v) || 0), 0 as any) as number;
-      case 'avg': return vals.length ? (vals.reduce((s, v) => (s as number) + (Number(v) || 0), 0 as any) as number) / vals.length : 0;
-      case 'min': return vals.reduce((m, v) => (v as any) < (m as any) ? v : m, vals[0]);
-      case 'max': return vals.reduce((m, v) => (v as any) > (m as any) ? v : m, vals[0]);
-      case 'collect': return JSON.stringify(vals);
-      default: return vals.length;
-    }
-  }
-
-  // -------------------------------------------------------------------------
-  // Ordering
-  // -------------------------------------------------------------------------
-
-  private _order(bindings: Bindings[], orderBy: OrderBy[]): Bindings[] {
-    return [...bindings].sort((a, b) => {
-      for (const o of orderBy) {
-        const va = a.get(o.variable);
-        const vb = b.get(o.variable);
-        if (va === vb) continue;
-        if (va === undefined) return 1;
-        if (vb === undefined) return -1;
-        const cmp = (va as any) < (vb as any) ? -1 : 1;
-        return o.direction === 'asc' ? cmp : -cmp;
-      }
-      return 0;
-    });
-  }
-
-  // -------------------------------------------------------------------------
-  // Projection
-  // -------------------------------------------------------------------------
-
-  private _project(bindings: Bindings[], select: string[]): Record<string, Atom>[] {
-    return bindings.map((b) => {
-      const row: Record<string, Atom> = {};
-      if (select.length === 0) {
-        for (const [k, v] of b) row[k] = v;
-      } else {
-        for (const s of select) {
-          const v = b.get(s);
-          if (v !== undefined) row[s] = v;
-        }
-      }
-      return row;
-    });
-  }
-
-  // -------------------------------------------------------------------------
-  // Helpers
-  // -------------------------------------------------------------------------
-
-  private _resolve(term: Term, bindings: Bindings): Atom | undefined {
-    if (isLiteral(term)) return term.value;
-    return bindings.get(term.name);
-  }
-
-  private _bind(term: Term, value: Atom, bindings: Bindings): boolean {
-    if (isLiteral(term)) return term.value === value;
-    const existing = bindings.get(term.name);
-    if (existing !== undefined) return existing === value;
-    bindings.set(term.name, value);
-    return true;
-  }
-
-  private _dedup(bindings: Bindings[]): Bindings[] {
-    const seen = new Set<string>();
-    return bindings.filter((b) => {
-      const key = [...b.entries()].sort(([a], [b]) => a.localeCompare(b))
-        .map(([k, v]) => `${k}=${v}`).join('\0');
-      if (seen.has(key)) return false;
-      seen.add(key);
-      return true;
-    });
-  }
-}