trellis 1.0.8 → 2.0.5

package/dist/kernel/logic-middleware.js

@@ -1,179 +0,0 @@
-// src/kernel/logic-middleware.ts
-class LogicMiddleware {
-  provider;
-  store;
-  aiProvider;
-  name = "logic-layer";
-  constructor(provider, store, aiProvider) {
-    this.provider = provider;
-    this.store = store;
-    this.aiProvider = aiProvider;
-  }
-  async handleQuery(query, ctx, next) {
-    const result = await next(query, ctx);
-    if (typeof query !== "string" || !result.rows || result.rows.length === 0) {
-      return result;
-    }
-    const enrichedRows = [...result.rows];
-    let changed = false;
-    for (let i = 0;i < enrichedRows.length; i++) {
-      const row = enrichedRows[i];
-      const entityType = this.extractEntityType(row);
-      if (!entityType)
-        continue;
-      const schema = this.provider.getOntology(`trellis:schema/${entityType.toLowerCase()}`);
-      if (!schema)
-        continue;
-      const virtualAttrs = schema.fields.filter((f) => f.valueType === "formula" || f.valueType === "rollup" || f.valueType === "ai_generated");
-      if (virtualAttrs.length > 0) {
-        const enrichedRow = { ...row };
-        for (const attr of virtualAttrs) {
-          if (attr.valueType === "formula" && attr.formula) {
-            const val = this.evaluateFormula(attr.formula, enrichedRow);
-            if (val !== undefined) {
-              const prefix = this.getVarPrefix(row);
-              if (prefix) {
-                enrichedRow[`${prefix}.${attr.name}`] = val;
-              }
-              enrichedRow[attr.name] = val;
-              changed = true;
-            }
-          } else if (attr.valueType === "rollup" && attr.rollup) {
-            const val = this.evaluateRollup(attr.rollup, enrichedRow);
-            if (val !== undefined) {
-              const prefix = this.getVarPrefix(row);
-              if (prefix) {
-                enrichedRow[`${prefix}.${attr.name}`] = val;
-              }
-              enrichedRow[attr.name] = val;
-              changed = true;
-            }
-          } else if (attr.valueType === "ai_generated" && attr.aiGenerated && this.aiProvider) {
-            const val = await this.evaluateAIGenerated(attr.aiGenerated, enrichedRow);
-            if (val !== undefined) {
-              const prefix = this.getVarPrefix(row);
-              if (prefix) {
-                enrichedRow[`${prefix}.${attr.name}`] = val;
-              }
-              enrichedRow[attr.name] = val;
-              changed = true;
-            }
-          }
-        }
-        enrichedRows[i] = enrichedRow;
-      }
-    }
-    return changed ? { ...result, rows: enrichedRows } : result;
-  }
-  async evaluateAIGenerated(aiConfig, row) {
-    if (!this.aiProvider)
-      return;
-    const cleanRow = this.getCleanRow(row);
-    return this.aiProvider.generate(aiConfig.prompt, cleanRow);
-  }
-  extractEntityType(row) {
-    for (const key of Object.keys(row)) {
-      if (key === "type" || key.endsWith(".type")) {
-        return row[key];
-      }
-    }
-    return;
-  }
-  getVarPrefix(row) {
-    for (const key of Object.keys(row)) {
-      if (key.startsWith("?") && key.includes(".")) {
-        return key.split(".")[0];
-      }
-    }
-    return;
-  }
-  getCleanRow(row) {
-    const cleanRow = {};
-    for (const [k, v] of Object.entries(row)) {
-      const cleanKey = k.includes(".") ? k.split(".").pop() : k;
-      cleanRow[cleanKey] = v;
-    }
-    return cleanRow;
-  }
-  evaluateRollup(rollup, row) {
-    const entityId = row["@id"] || row["id"] || row[this.getVarPrefix(row) + ".@id"];
-    if (!entityId)
-      return;
-    const links = this.store.getLinksByEntityAndAttribute(entityId, rollup.relationProperty);
-    const targetEntities = links.map((l) => l.e2);
-    if (rollup.aggregation === "count") {
-      return targetEntities.length;
-    }
-    const values = [];
-    for (const targetId of targetEntities) {
-      const facts = this.store.getFactsByEntity(targetId);
-      const targetFact = facts.find((f) => f.a === rollup.targetProperty);
-      if (targetFact) {
-        values.push(targetFact.v);
-      }
-    }
-    if (values.length === 0)
-      return 0;
-    switch (rollup.aggregation) {
-      case "sum":
-        return values.reduce((a, b) => typeof b === "number" ? a + b : a, 0);
-      case "avg":
-        const sum = values.reduce((a, b) => typeof b === "number" ? a + b : a, 0);
-        return sum / values.length;
-      case "min":
-        return Math.min(...values.filter((v) => typeof v === "number"));
-      case "max":
-        return Math.max(...values.filter((v) => typeof v === "number"));
-      case "median":
-        const nums = values.filter((v) => typeof v === "number").sort((a, b) => a - b);
-        if (nums.length === 0)
-          return 0;
-        const mid = Math.floor(nums.length / 2);
-        return nums.length % 2 !== 0 ? nums[mid] : (nums[mid - 1] + nums[mid]) / 2;
-      case "mode":
-        if (values.length === 0)
-          return;
-        const counts = new Map;
-        let maxCount = 0;
-        let mode = values[0];
-        for (const v of values) {
-          const count = (counts.get(v) || 0) + 1;
-          counts.set(v, count);
-          if (count > maxCount) {
-            maxCount = count;
-            mode = v;
-          }
-        }
-        return mode;
-      default:
-        return;
-    }
-  }
-  evaluateFormula(formula, row) {
-    try {
-      const cleanRow = this.getCleanRow(row);
-      let expr = formula;
-      expr = expr.replace(/\$if\((.*?), (.*?), (.*?)\)/g, "($1 ? $2 : $3)");
-      expr = expr.replace(/\$concat\((.*?)\)/g, (match, args) => {
-        return args.split(",").map((a) => a.trim()).join(" + ");
-      });
-      const tokens = expr.split(/([-+*/()<>!=&|?, ]+)/).filter((t) => t.trim().length > 0);
-      for (const token of tokens) {
-        if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(token) && !["true", "false", "null", "undefined"].includes(token)) {
-          const val = cleanRow[token];
-          if (val !== undefined) {
-            const stringified = typeof val === "string" ? `"${val.replace(/"/g, "\\\"")}"` : String(val);
-            expr = expr.replace(new RegExp(`\\b${token}\\b`, "g"), stringified);
-          }
-        }
-      }
-      return new Function(`return (${expr})`)();
-    } catch (e) {
-      console.warn(`[logic] Formula evaluation failed: ${formula}`, e);
-      return;
-    }
-  }
-}
-export {
-  LogicMiddleware
-};

package/dist/kernel/operations.js

@@ -1,32 +0,0 @@
-// src/kernel/operations.ts
-async function hashOp(op) {
-  const content = JSON.stringify({
-    kind: op.kind,
-    timestamp: op.timestamp,
-    agentId: op.agentId,
-    previousHash: op.previousHash,
-    facts: op.facts,
-    links: op.links
-  });
-  const msgUint8 = new TextEncoder().encode(content);
-  const hashBuffer = await crypto.subtle.digest("SHA-256", msgUint8);
-  const hashArray = Array.from(new Uint8Array(hashBuffer));
-  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-  return `trellis:op:${hashHex}`;
-}
-async function createOp(kind, params) {
-  const opBase = {
-    kind,
-    timestamp: new Date().toISOString(),
-    agentId: params.agentId,
-    previousHash: params.previousHash,
-    facts: params.facts,
-    links: params.links
-  };
-  const hash = await hashOp(opBase);
-  return { ...opBase, hash };
-}
-export {
-  hashOp,
-  createOp
-};

package/dist/kernel/schema-middleware.js

@@ -1,34 +0,0 @@
-// src/kernel/schema-middleware.ts
-class SchemaMiddleware {
-  provider;
-  name = "schema-enforcement";
-  constructor(provider) {
-    this.provider = provider;
-  }
-  async handleOp(op, ctx, next) {
-    if (ctx.system || ctx.remote) {
-      return next(op, ctx);
-    }
-    if (op.kind === "addFacts" && op.facts) {
-      const typeFact = op.facts.find((f) => f.a === "type");
-      if (typeFact && typeof typeFact.v === "string") {
-        const type = typeFact.v;
-        const schema = this.provider.getOntology(`trellis:schema/${type.toLowerCase()}`);
-        if (schema) {
-          const allowedFields = new Set(schema.fields.map((f) => f.name));
-          allowedFields.add("type");
-          allowedFields.add("@id");
-          for (const fact of op.facts) {
-            if (!allowedFields.has(fact.a)) {
-              throw new Error(`Schema violation: attribute "${fact.a}" is not allowed for entity type "${type}".`);
-            }
-          }
-        }
-      }
-    }
-    return next(op, ctx);
-  }
-}
-export {
-  SchemaMiddleware
-};

package/dist/kernel/security-middleware.js

@@ -1,53 +0,0 @@
-// src/kernel/security-middleware.ts
-class SecurityMiddleware {
-  provider;
-  name = "security";
-  constructor(provider) {
-    this.provider = provider;
-  }
-  async handleOp(op, ctx, next) {
-    const agentId = ctx.agentId || "anonymous";
-    if (ctx.system) {
-      return next(op, ctx);
-    }
-    let targetEntityId;
-    let targetEntityType;
-    if (op.facts && op.facts.length > 0) {
-      const firstFact = op.facts[0];
-      targetEntityId = firstFact.e;
-      const typeFact = op.facts.find((f) => f.a === "type");
-      if (typeFact && typeof typeFact.v === "string") {
-        targetEntityType = typeFact.v;
-      }
-    } else if (op.links && op.links.length > 0) {
-      targetEntityId = op.links[0].e1;
-    }
-    const allowed = await this.provider.can({
-      agentId,
-      action: "mutate",
-      targetEntityId,
-      targetEntityType
-    });
-    if (!allowed) {
-      throw new Error(`Security violation: agent ${agentId} is not authorized to mutate kernel state${targetEntityId ? ` for entity ${targetEntityId}` : ""}.`);
-    }
-    return next(op, ctx);
-  }
-  async handleQuery(query, ctx, next) {
-    const agentId = ctx.agentId || "anonymous";
-    if (ctx.system) {
-      return next(query, ctx);
-    }
-    const allowed = await this.provider.can({
-      agentId,
-      action: "query"
-    });
-    if (!allowed) {
-      throw new Error(`Security violation: agent ${agentId} is not authorized to query the kernel.`);
-    }
-    return next(query, ctx);
-  }
-}
-export {
-  SecurityMiddleware
-};