trellis 2.0.13 → 2.1.2

package/src/core/persist/sqlite-backend.ts

@@ -1,298 +0,0 @@
-/**
- * SQLite-backed Kernel Backend
- *
- * Replaces the P0 JsonOpLog with a proper WAL-mode SQLite database.
- * Stores ops, snapshots, and blobs in a single database file.
- *
- * @module trellis/core
- */
-
-import { Database } from 'bun:sqlite';
-import type { KernelOp, KernelBackend } from './backend.js';
-
-// ---------------------------------------------------------------------------
-// Schema
-// ---------------------------------------------------------------------------
-
-const SCHEMA_SQL = `
-CREATE TABLE IF NOT EXISTS ops (
-  hash TEXT PRIMARY KEY,
-  kind TEXT NOT NULL,
-  timestamp TEXT NOT NULL,
-  agent_id TEXT NOT NULL,
-  previous_hash TEXT,
-  payload TEXT NOT NULL
-);
-
-CREATE TABLE IF NOT EXISTS snapshots (
-  id INTEGER PRIMARY KEY AUTOINCREMENT,
-  last_op_hash TEXT NOT NULL,
-  data TEXT NOT NULL,
-  created_at TEXT NOT NULL DEFAULT (datetime('now'))
-);
-
-CREATE TABLE IF NOT EXISTS blobs (
-  hash TEXT PRIMARY KEY,
-  content BLOB NOT NULL
-);
-
-CREATE INDEX IF NOT EXISTS idx_ops_kind ON ops(kind);
-CREATE INDEX IF NOT EXISTS idx_ops_timestamp ON ops(timestamp);
-CREATE INDEX IF NOT EXISTS idx_ops_agent ON ops(agent_id);
-CREATE INDEX IF NOT EXISTS idx_ops_previous ON ops(previous_hash);
-CREATE INDEX IF NOT EXISTS idx_snapshots_op ON snapshots(last_op_hash);
-`;
-
-// ---------------------------------------------------------------------------
-// Implementation
-// ---------------------------------------------------------------------------
-
-export class SqliteKernelBackend implements KernelBackend {
-  private db: Database;
-  private _stmts: {
-    insert: ReturnType<Database['prepare']>;
-    readAll: ReturnType<Database['prepare']>;
-    readUntil: ReturnType<Database['prepare']>;
-    readAfter: ReturnType<Database['prepare']>;
-    getByHash: ReturnType<Database['prepare']>;
-    getLast: ReturnType<Database['prepare']>;
-    count: ReturnType<Database['prepare']>;
-    saveSnapshot: ReturnType<Database['prepare']>;
-    loadSnapshot: ReturnType<Database['prepare']>;
-    putBlob: ReturnType<Database['prepare']>;
-    getBlob: ReturnType<Database['prepare']>;
-    hasBlob: ReturnType<Database['prepare']>;
-  } | null = null;
-
-  constructor(private dbPath: string) {
-    this.db = new Database(dbPath);
-  }
-
-  init(): void {
-    this.db.exec('PRAGMA journal_mode=WAL;');
-    this.db.exec('PRAGMA foreign_keys=ON;');
-    this.db.exec('PRAGMA synchronous=NORMAL;');
-    this.db.exec(SCHEMA_SQL);
-    this._prepareStatements();
-  }
-
-  private _prepareStatements(): void {
-    this._stmts = {
-      insert: this.db.prepare(`
-        INSERT OR IGNORE INTO ops (hash, kind, timestamp, agent_id, previous_hash, payload)
-        VALUES ($hash, $kind, $timestamp, $agentId, $previousHash, $payload)
-      `),
-      readAll: this.db.prepare(`
-        SELECT hash, kind, timestamp, agent_id, previous_hash, payload
-        FROM ops ORDER BY rowid ASC
-      `),
-      readUntil: this.db.prepare(`
-        SELECT hash, kind, timestamp, agent_id, previous_hash, payload
-        FROM ops WHERE rowid <= (SELECT rowid FROM ops WHERE hash = $hash)
-        ORDER BY rowid ASC
-      `),
-      readAfter: this.db.prepare(`
-        SELECT hash, kind, timestamp, agent_id, previous_hash, payload
-        FROM ops WHERE rowid > (SELECT rowid FROM ops WHERE hash = $hash)
-        ORDER BY rowid ASC
-      `),
-      getByHash: this.db.prepare(`
-        SELECT hash, kind, timestamp, agent_id, previous_hash, payload
-        FROM ops WHERE hash = $hash
-      `),
-      getLast: this.db.prepare(`
-        SELECT hash, kind, timestamp, agent_id, previous_hash, payload
-        FROM ops ORDER BY rowid DESC LIMIT 1
-      `),
-      count: this.db.prepare('SELECT COUNT(*) as cnt FROM ops'),
-      saveSnapshot: this.db.prepare(`
-        INSERT INTO snapshots (last_op_hash, data)
-        VALUES ($lastOpHash, $data)
-      `),
-      loadSnapshot: this.db.prepare(`
-        SELECT last_op_hash, data FROM snapshots
-        ORDER BY id DESC LIMIT 1
-      `),
-      putBlob: this.db.prepare(`
-        INSERT OR IGNORE INTO blobs (hash, content) VALUES ($hash, $content)
-      `),
-      getBlob: this.db.prepare(`
-        SELECT content FROM blobs WHERE hash = $hash
-      `),
-      hasBlob: this.db.prepare(`
-        SELECT 1 FROM blobs WHERE hash = $hash
-      `),
-    };
-  }
-
-  // -------------------------------------------------------------------------
-  // Op operations
-  // -------------------------------------------------------------------------
-
-  append(op: KernelOp): void {
-    const payload = JSON.stringify({
-      facts: op.facts,
-      links: op.links,
-      ...(op.deleteFacts?.length ? { deleteFacts: op.deleteFacts } : {}),
-      ...(op.deleteLinks?.length ? { deleteLinks: op.deleteLinks } : {}),
-      ...((op as any).vcs ? { vcs: (op as any).vcs } : {}),
-      ...((op as any).signature ? { signature: (op as any).signature } : {}),
-    });
-
-    this._stmts!.insert.run({
-      $hash: op.hash,
-      $kind: op.kind,
-      $timestamp: op.timestamp,
-      $agentId: op.agentId,
-      $previousHash: op.previousHash ?? null,
-      $payload: payload,
-    });
-  }
-
-  appendBatch(ops: KernelOp[]): void {
-    if (ops.length === 0) return;
-    this.db.transaction(() => {
-      for (const op of ops) {
-        this.append(op);
-      }
-    })();
-  }
-
-  readAll(): KernelOp[] {
-    const rows = this._stmts!.readAll.all() as any[];
-    return rows.map(rowToOp);
-  }
-
-  readUntil(hash: string): KernelOp[] {
-    const rows = this._stmts!.readUntil.all({ $hash: hash }) as any[];
-    return rows.map(rowToOp);
-  }
-
-  readAfter(hash: string): KernelOp[] {
-    const rows = this._stmts!.readAfter.all({ $hash: hash }) as any[];
-    return rows.map(rowToOp);
-  }
-
-  readUntilTimestamp(isoTimestamp: string): KernelOp[] {
-    const rows = this.db
-      .prepare(
-        `SELECT hash, kind, timestamp, agent_id, previous_hash, payload
-         FROM ops WHERE timestamp <= $ts ORDER BY rowid ASC`,
-      )
-      .all({ $ts: isoTimestamp }) as any[];
-    return rows.map(rowToOp);
-  }
-
-  getLastOp(): KernelOp | undefined {
-    const row = this._stmts!.getLast.get() as any;
-    return row ? rowToOp(row) : undefined;
-  }
-
-  getOpByHash(hash: string): KernelOp | undefined {
-    const row = this._stmts!.getByHash.get({ $hash: hash }) as any;
-    return row ? rowToOp(row) : undefined;
-  }
-
-  count(): number {
-    const row = this._stmts!.count.get() as any;
-    return row?.cnt ?? 0;
-  }
-
-  /**
-   * Find the common ancestor op of two op hashes by walking
-   * previousHash chains until they converge.
-   */
-  findCommonAncestor(hashA: string, hashB: string): KernelOp | undefined {
-    // Collect ancestors of A
-    const ancestorsA = new Set<string>();
-    let cursor: string | undefined = hashA;
-    while (cursor) {
-      ancestorsA.add(cursor);
-      const op = this.getOpByHash(cursor);
-      cursor = op?.previousHash;
-    }
-
-    // Walk B's chain until we find a common ancestor
-    cursor = hashB;
-    while (cursor) {
-      if (ancestorsA.has(cursor)) {
-        return this.getOpByHash(cursor);
-      }
-      const op = this.getOpByHash(cursor);
-      cursor = op?.previousHash;
-    }
-
-    return undefined;
-  }
-
-  // -------------------------------------------------------------------------
-  // Snapshot operations
-  // -------------------------------------------------------------------------
-
-  saveSnapshot(lastOpHash: string, data: any): void {
-    this._stmts!.saveSnapshot.run({
-      $lastOpHash: lastOpHash,
-      $data: JSON.stringify(data),
-    });
-  }
-
-  loadLatestSnapshot(): { lastOpHash: string; data: any } | undefined {
-    const row = this._stmts!.loadSnapshot.get() as any;
-    if (!row) return undefined;
-    return {
-      lastOpHash: row.last_op_hash,
-      data: JSON.parse(row.data),
-    };
-  }
-
-  // -------------------------------------------------------------------------
-  // Blob operations
-  // -------------------------------------------------------------------------
-
-  putBlob(hash: string, content: Uint8Array): void {
-    this._stmts!.putBlob.run({
-      $hash: hash,
-      $content: Buffer.from(content),
-    });
-  }
-
-  getBlob(hash: string): Uint8Array | undefined {
-    const row = this._stmts!.getBlob.get({ $hash: hash }) as any;
-    if (!row) return undefined;
-    return new Uint8Array(row.content);
-  }
-
-  hasBlob(hash: string): boolean {
-    return !!this._stmts!.hasBlob.get({ $hash: hash });
-  }
-
-  // -------------------------------------------------------------------------
-  // Lifecycle
-  // -------------------------------------------------------------------------
-
-  close(): void {
-    this.db.close();
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function rowToOp(row: any): KernelOp {
-  const payload = JSON.parse(row.payload);
-  const op: any = {
-    hash: row.hash,
-    kind: row.kind,
-    timestamp: row.timestamp,
-    agentId: row.agent_id,
-  };
-  if (row.previous_hash) op.previousHash = row.previous_hash;
-  if (payload.facts) op.facts = payload.facts;
-  if (payload.links) op.links = payload.links;
-  if (payload.deleteFacts) op.deleteFacts = payload.deleteFacts;
-  if (payload.deleteLinks) op.deleteLinks = payload.deleteLinks;
-  if (payload.vcs) op.vcs = payload.vcs;
-  if (payload.signature) op.signature = payload.signature;
-  return op;
-}

package/src/core/plugins/index.ts

@@ -1,17 +0,0 @@
-/**
- * Plugin System — Public API Surface
- *
- * @module trellis/core/plugins
- */
-
-export { PluginRegistry, EventBus } from './registry.js';
-
-export type {
-  PluginDef,
-  PluginContext,
-  PluginManifest,
-  EventCallback,
-  EventHandler,
-  WellKnownEvent,
-  WorkspaceConfig,
-} from './types.js';

package/src/core/plugins/registry.ts

@@ -1,322 +0,0 @@
-/**
- * Plugin Registry — Load, register, and manage plugins.
- *
- * Handles plugin lifecycle, dependency resolution, event dispatching,
- * and workspace configuration.
- *
- * @module trellis/core/plugins
- */
-
-import type { TrellisKernel } from '../kernel/trellis-kernel.js';
-import type { OntologyRegistry } from '../ontology/registry.js';
-import type { QueryEngine } from '../query/engine.js';
-import type {
-  PluginDef,
-  PluginContext,
-  PluginManifest,
-  EventCallback,
-  EventHandler,
-  WorkspaceConfig,
-} from './types.js';
-
-// ---------------------------------------------------------------------------
-// Event Bus
-// ---------------------------------------------------------------------------
-
-export class EventBus {
-  private handlers: Map<string, Set<EventCallback>> = new Map();
-
-  on(event: string, handler: EventCallback): void {
-    const set = this.handlers.get(event) ?? new Set();
-    set.add(handler);
-    this.handlers.set(event, set);
-  }
-
-  off(event: string, handler: EventCallback): void {
-    const set = this.handlers.get(event);
-    if (set) {
-      set.delete(handler);
-      if (set.size === 0) this.handlers.delete(event);
-    }
-  }
-
-  async emit(event: string, data?: unknown): Promise<void> {
-    // Exact match
-    const exact = this.handlers.get(event);
-    if (exact) {
-      for (const h of exact) await h(data);
-    }
-
-    // Wildcard match (e.g. "op:*" matches "op:applied")
-    for (const [pattern, handlers] of this.handlers) {
-      if (pattern === event) continue; // Already handled
-      if (pattern.endsWith('*') && event.startsWith(pattern.slice(0, -1))) {
-        for (const h of handlers) await h(data);
-      }
-    }
-  }
-
-  listEvents(): string[] {
-    return [...this.handlers.keys()];
-  }
-
-  clear(): void {
-    this.handlers.clear();
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Plugin Registry
-// ---------------------------------------------------------------------------
-
-export class PluginRegistry {
-  private plugins: Map<string, { def: PluginDef; loaded: boolean }> = new Map();
-  private eventBus: EventBus = new EventBus();
-  private workspaceConfig: WorkspaceConfig = {};
-  private logs: Array<{ pluginId: string; message: string; timestamp: string }> = [];
-
-  /**
-   * Register a plugin definition. Does not load it yet.
-   */
-  register(def: PluginDef): void {
-    if (this.plugins.has(def.id)) {
-      throw new Error(`Plugin "${def.id}" is already registered.`);
-    }
-    this.plugins.set(def.id, { def, loaded: false });
-  }
-
-  /**
-   * Unregister a plugin. Unloads it first if loaded.
-   */
-  async unregister(id: string): Promise<void> {
-    const entry = this.plugins.get(id);
-    if (!entry) return;
-    if (entry.loaded) await this.unload(id);
-    this.plugins.delete(id);
-  }
-
-  /**
-   * Load a plugin (call onLoad, register middleware/ontologies/rules/events).
-   * Resolves dependencies first.
-   */
-  async load(
-    id: string,
-    kernel?: TrellisKernel,
-    ontologyRegistry?: OntologyRegistry,
-    queryEngine?: QueryEngine,
-  ): Promise<void> {
-    const entry = this.plugins.get(id);
-    if (!entry) throw new Error(`Plugin "${id}" is not registered.`);
-    if (entry.loaded) return;
-
-    // Check dependencies
-    if (entry.def.dependencies) {
-      for (const dep of entry.def.dependencies) {
-        const depEntry = this.plugins.get(dep);
-        if (!depEntry) {
-          throw new Error(`Plugin "${id}" depends on "${dep}" which is not registered.`);
-        }
-        if (!depEntry.loaded) {
-          await this.load(dep, kernel, ontologyRegistry, queryEngine);
-        }
-      }
-    }
-
-    // Register middleware
-    if (entry.def.middleware && kernel) {
-      for (const mw of entry.def.middleware) {
-        kernel.addMiddleware(mw);
-      }
-    }
-
-    // Register ontologies
-    if (entry.def.ontologies && ontologyRegistry) {
-      for (const schema of entry.def.ontologies) {
-        try { ontologyRegistry.register(schema); } catch {}
-      }
-    }
-
-    // Register rules
-    if (entry.def.rules && queryEngine) {
-      for (const rule of entry.def.rules) {
-        queryEngine.addRule(rule);
-      }
-    }
-
-    // Register event handlers
-    if (entry.def.eventHandlers) {
-      for (const eh of entry.def.eventHandlers) {
-        this.eventBus.on(eh.event, eh.handler);
-      }
-    }
-
-    // Build plugin context
-    const ctx = this._buildContext(id);
-
-    // Call onLoad
-    if (entry.def.onLoad) {
-      await entry.def.onLoad(ctx);
-    }
-
-    entry.loaded = true;
-    await this.eventBus.emit('plugin:loaded', { pluginId: id });
-  }
-
-  /**
-   * Unload a plugin (call onUnload, remove middleware/events).
-   */
-  async unload(id: string): Promise<void> {
-    const entry = this.plugins.get(id);
-    if (!entry || !entry.loaded) return;
-
-    const ctx = this._buildContext(id);
-    if (entry.def.onUnload) {
-      await entry.def.onUnload(ctx);
-    }
-
-    // Remove event handlers
-    if (entry.def.eventHandlers) {
-      for (const eh of entry.def.eventHandlers) {
-        this.eventBus.off(eh.event, eh.handler);
-      }
-    }
-
-    entry.loaded = false;
-    await this.eventBus.emit('plugin:unloaded', { pluginId: id });
-  }
-
-  /**
-   * Load all registered plugins in dependency order.
-   */
-  async loadAll(
-    kernel?: TrellisKernel,
-    ontologyRegistry?: OntologyRegistry,
-    queryEngine?: QueryEngine,
-  ): Promise<void> {
-    const order = this._resolveDependencyOrder();
-    for (const id of order) {
-      await this.load(id, kernel, ontologyRegistry, queryEngine);
-    }
-  }
-
-  /**
-   * Unload all plugins in reverse order.
-   */
-  async unloadAll(): Promise<void> {
-    const order = this._resolveDependencyOrder().reverse();
-    for (const id of order) {
-      await this.unload(id);
-    }
-  }
-
-  // -------------------------------------------------------------------------
-  // Queries
-  // -------------------------------------------------------------------------
-
-  get(id: string): PluginDef | undefined {
-    return this.plugins.get(id)?.def;
-  }
-
-  isLoaded(id: string): boolean {
-    return this.plugins.get(id)?.loaded ?? false;
-  }
-
-  list(): Array<{ def: PluginDef; loaded: boolean }> {
-    return [...this.plugins.values()];
-  }
-
-  listLoaded(): PluginDef[] {
-    return [...this.plugins.values()]
-      .filter((e) => e.loaded)
-      .map((e) => e.def);
-  }
-
-  // -------------------------------------------------------------------------
-  // Event bus access
-  // -------------------------------------------------------------------------
-
-  getEventBus(): EventBus {
-    return this.eventBus;
-  }
-
-  async emit(event: string, data?: unknown): Promise<void> {
-    await this.eventBus.emit(event, data);
-  }
-
-  on(event: string, handler: EventCallback): void {
-    this.eventBus.on(event, handler);
-  }
-
-  // -------------------------------------------------------------------------
-  // Workspace config
-  // -------------------------------------------------------------------------
-
-  getWorkspaceConfig(): WorkspaceConfig {
-    return this.workspaceConfig;
-  }
-
-  setWorkspaceConfig(config: WorkspaceConfig): void {
-    this.workspaceConfig = config;
-  }
-
-  getConfigValue(key: string): unknown {
-    return this.workspaceConfig.settings?.[key];
-  }
-
-  setConfigValue(key: string, value: unknown): void {
-    if (!this.workspaceConfig.settings) this.workspaceConfig.settings = {};
-    this.workspaceConfig.settings[key] = value;
-  }
-
-  // -------------------------------------------------------------------------
-  // Logs
-  // -------------------------------------------------------------------------
-
-  getLogs(pluginId?: string): typeof this.logs {
-    if (pluginId) return this.logs.filter((l) => l.pluginId === pluginId);
-    return [...this.logs];
-  }
-
-  // -------------------------------------------------------------------------
-  // Internal
-  // -------------------------------------------------------------------------
-
-  private _buildContext(pluginId: string): PluginContext {
-    return {
-      pluginId,
-      on: (event, handler) => this.eventBus.on(event, handler),
-      emit: (event, data) => { this.eventBus.emit(event, data); },
-      getConfig: (key) => this.getConfigValue(key),
-      log: (message) => {
-        this.logs.push({ pluginId, message, timestamp: new Date().toISOString() });
-      },
-    };
-  }
-
-  private _resolveDependencyOrder(): string[] {
-    const visited = new Set<string>();
-    const order: string[] = [];
-
-    const visit = (id: string, stack: Set<string>) => {
-      if (visited.has(id)) return;
-      if (stack.has(id)) throw new Error(`Circular dependency detected: ${[...stack, id].join(' → ')}`);
-
-      stack.add(id);
-      const entry = this.plugins.get(id);
-      if (entry?.def.dependencies) {
-        for (const dep of entry.def.dependencies) {
-          visit(dep, stack);
-        }
-      }
-      stack.delete(id);
-      visited.add(id);
-      order.push(id);
-    };
-
-    for (const id of this.plugins.keys()) {
-      visit(id, new Set());
-    }
-
-    return order;
-  }
-}