trellis 2.1.9 → 3.0.2

package/dist/{import-fyg5sgq4.js → import-s2b8e0ft.js}

@@ -2,8 +2,8 @@
 import {
   importFile,
   importRecords
-} from "./index-8fjwnztt.js";
-import"./index-5bhe57y9.js";
+} from "./index-skhn0agf.js";
+import"./index-yhwjgfvj.js";
 import"./index-a76rekgs.js";
 export {
   importRecords,

package/dist/{index-3ejh8k6v.js → index-0q7wbasy.js}

@@ -26,6 +26,13 @@ function decompose(op) {
   const vcs = op.vcs;
   if (!vcs)
     return result;
+  if (vcs.issueId && vcs.oldIssueStatus) {
+    result.deleteFacts.push({
+      e: issueEntityId(vcs.issueId),
+      a: "status",
+      v: vcs.oldIssueStatus
+    });
+  }
   switch (op.kind) {
     case "vcs:fileAdd": {
       if (!vcs.filePath)
@@ -1268,6 +1275,7 @@ async function updateIssue(ctx, id, updates) {
       issueId: id,
       issueTitle: updates.title,
       issueDescription: updates.description,
+      oldIssueStatus: updates.status ? getIssueFact(ctx, issueEntityId(id), "status") : undefined,
       issueStatus: updates.status,
       issuePriority: updates.priority,
       issueLabels: updates.labels,
@@ -1291,6 +1299,7 @@ async function startIssue(ctx, id, branchName) {
     previousHash: ctx.getLastOp()?.hash,
     vcs: {
       issueId: id,
+      oldIssueStatus: status,
       issueAssignee: ctx.agentId,
       branchName
     }
@@ -1310,7 +1319,11 @@ async function pauseIssue(ctx, id, note) {
   const op = await createVcsOp("vcs:issuePause", {
     agentId: ctx.agentId,
     previousHash: ctx.getLastOp()?.hash,
-    vcs: { issueId: id, pauseNote: note.trim() }
+    vcs: {
+      issueId: id,
+      oldIssueStatus: status,
+      pauseNote: note.trim()
+    }
   });
   ctx.applyOp(op);
   return op;
@@ -1324,7 +1337,7 @@ async function resumeIssue(ctx, id) {
   const op = await createVcsOp("vcs:issueResume", {
     agentId: ctx.agentId,
     previousHash: ctx.getLastOp()?.hash,
-    vcs: { issueId: id }
+    vcs: { issueId: id, oldIssueStatus: status }
   });
   ctx.applyOp(op);
   return op;
@@ -1356,7 +1369,7 @@ async function closeIssue(ctx, id, opts) {
   const op = await createVcsOp("vcs:issueClose", {
     agentId: ctx.agentId,
     previousHash: ctx.getLastOp()?.hash,
-    vcs: { issueId: id }
+    vcs: { issueId: id, oldIssueStatus: status }
   });
   ctx.applyOp(op);
   if (startedAt) {
@@ -1376,6 +1389,7 @@ async function triageIssue(ctx, id) {
     previousHash: ctx.getLastOp()?.hash,
     vcs: {
       issueId: id,
+      oldIssueStatus: status,
       issueStatus: "queue"
     }
   });
@@ -1391,7 +1405,7 @@ async function reopenIssue(ctx, id) {
   const op = await createVcsOp("vcs:issueReopen", {
     agentId: ctx.agentId,
     previousHash: ctx.getLastOp()?.hash,
-    vcs: { issueId: id }
+    vcs: { issueId: id, oldIssueStatus: status }
   });
   ctx.applyOp(op);
   return op;

package/dist/{index-7t92ej34.js → index-0zk3fx2s.js}

@@ -2,13 +2,299 @@
 import {
   EAVStore,
   init_eav_store
-} from "./index-5bhe57y9.js";
+} from "./index-yhwjgfvj.js";
 import {
   QueryEngine
 } from "./index-yp88he8n.js";
 
 // src/core/kernel/trellis-kernel.ts
 init_eav_store();
+
+// src/core/ontology/core-ontology.ts
+var VERSION = "1.0.0";
+function f(name, valueType, opts) {
+  return { name, valueType, ...opts };
+}
+var thing = {
+  "@id": "core:Thing",
+  "@type": "trellis:Schema",
+  version: VERSION,
+  tier: "core",
+  label: "Thing",
+  icon: "lucide:box",
+  fields: [
+    f("id", "title", { required: true }),
+    f("createdAt", "date"),
+    f("updatedAt", "date"),
+    f("createdBy", "relation", {
+      relation: { targetSchema: "core:Member", cardinality: "one" }
+    }),
+    f("tags", "multi_select")
+  ]
+};
+var record = {
+  "@id": "core:Record",
+  "@type": "trellis:Schema",
+  version: VERSION,
+  tier: "core",
+  subClassOf: "core:Thing",
+  label: "Record",
+  icon: "lucide:file",
+  fields: [
+    f("title", "title", { required: true }),
+    f("description", "rich_text"),
+    f("status", "select"),
+    f("tags", "multi_select")
+  ]
+};
+var document = {
+  "@id": "core:Document",
+  "@type": "trellis:Schema",
+  version: VERSION,
+  tier: "core",
+  subClassOf: "core:Record",
+  label: "Document",
+  icon: "lucide:file-text",
+  fields: [
+    f("content", "rich_text"),
+    f("mimeType", "rich_text"),
+    f("fileUrl", "url")
+  ]
+};
+var event = {
+  "@id": "core:Event",
+  "@type": "trellis:Schema",
+  version: VERSION,
+  tier: "core",
+  subClassOf: "core:Record",
+  label: "Event",
+  icon: "lucide:calendar",
+  fields: [
+    f("startDate", "date"),
+    f("endDate", "date"),
+    f("location", "rich_text"),
+    f("allDay", "checkbox")
+  ]
+};
+var collection = {
+  "@id": "core:Collection",
+  "@type": "trellis:Schema",
+  version: VERSION,
+  tier: "core",
+  subClassOf: "core:Thing",
+  label: "Collection",
+  icon: "lucide:database",
+  fields: [
+    f("title", "title", { required: true }),
+    f("description", "rich_text"),
+    f("icon", "rich_text"),
+    f("schema", "rich_text"),
+    f("recordType", "relation", {
+      relation: { targetSchema: "core:Record", cardinality: "one" }
+    })
+  ]
+};
+var tag = {
+  "@id": "core:Tag",
+  "@type": "trellis:Schema",
+  version: VERSION,
+  tier: "core",
+  subClassOf: "core:Thing",
+  label: "Tag",
+  icon: "lucide:tag",
+  fields: [
+    f("name", "title", { required: true }),
+    f("slug", "rich_text"),
+    f("color", "rich_text"),
+    f("icon", "rich_text"),
+    f("parentTag", "relation", {
+      relation: { targetSchema: "core:Tag", cardinality: "one" }
+    })
+  ]
+};
+var workspace = {
+  "@id": "core:Workspace",
+  "@type": "trellis:Schema",
+  version: VERSION,
+  tier: "core",
+  subClassOf: "core:Thing",
+  label: "Workspace",
+  icon: "lucide:building-2",
+  fields: [
+    f("name", "title", { required: true }),
+    f("slug", "rich_text"),
+    f("avatar", "files"),
+    f("plan", "select")
+  ]
+};
+var app = {
+  "@id": "core:App",
+  "@type": "trellis:Schema",
+  version: VERSION,
+  tier: "core",
+  subClassOf: "core:Thing",
+  label: "App",
+  icon: "lucide:layout-grid",
+  fields: [
+    f("name", "title", { required: true }),
+    f("slug", "rich_text"),
+    f("icon", "rich_text"),
+    f("color", "rich_text"),
+    f("description", "rich_text"),
+    f("ontologies", "multi_select")
+  ]
+};
+var member = {
+  "@id": "core:Member",
+  "@type": "trellis:Schema",
+  version: VERSION,
+  tier: "core",
+  subClassOf: "core:Thing",
+  label: "Member",
+  icon: "lucide:user",
+  fields: [
+    f("name", "title", { required: true }),
+    f("email", "email"),
+    f("avatar", "files"),
+    f("role", "select", {
+      required: true,
+      selectOptions: ["owner", "admin", "member", "guest"],
+      defaultValue: "member"
+    }),
+    f("status", "select", {
+      required: true,
+      selectOptions: ["pending", "active", "suspended"],
+      defaultValue: "pending"
+    }),
+    f("orgId", "relation", {
+      required: true,
+      relation: { targetSchema: "core:Workspace", cardinality: "one" }
+    }),
+    f("userId", "relation", {
+      relation: { targetSchema: "core:Person", cardinality: "one" }
+    }),
+    f("invitedAt", "date"),
+    f("joinedAt", "date")
+  ]
+};
+var notification = {
+  "@id": "core:Notification",
+  "@type": "trellis:Schema",
+  version: VERSION,
+  tier: "core",
+  subClassOf: "core:Thing",
+  label: "Notification",
+  icon: "lucide:bell",
+  fields: [
+    f("recipientId", "relation", {
+      required: true,
+      relation: { targetSchema: "core:Person", cardinality: "one" }
+    }),
+    f("orgId", "relation", {
+      relation: { targetSchema: "core:Workspace", cardinality: "one" }
+    }),
+    f("orgName", "rich_text"),
+    f("type", "select", {
+      required: true,
+      selectOptions: [
+        "invite_accepted",
+        "invite_sent",
+        "member_joined",
+        "member_removed",
+        "role_changed",
+        "mention",
+        "comment",
+        "entity_updated",
+        "system"
+      ]
+    }),
+    f("title", "title", { required: true }),
+    f("message", "rich_text", { required: true }),
+    f("actionUrl", "url"),
+    f("icon", "rich_text"),
+    f("variant", "select", {
+      selectOptions: ["default", "success", "warning", "destructive", "info"]
+    }),
+    f("isRead", "checkbox", { defaultValue: false }),
+    f("actorId", "relation", {
+      relation: { targetSchema: "core:Person", cardinality: "one" }
+    }),
+    f("actorName", "rich_text"),
+    f("metadata", "rich_text"),
+    f("createdAt", "date", { required: true })
+  ]
+};
+var share = {
+  "@id": "core:Share",
+  "@type": "trellis:Schema",
+  version: VERSION,
+  tier: "core",
+  subClassOf: "core:Thing",
+  label: "Share",
+  icon: "lucide:share-2",
+  fields: [
+    f("entityId", "relation", { required: true }),
+    f("entityType", "select", { selectOptions: ["entity", "collection"] }),
+    f("userId", "relation", {
+      required: true,
+      relation: { targetSchema: "core:Person", cardinality: "one" }
+    }),
+    f("orgId", "relation", {
+      relation: { targetSchema: "core:Workspace", cardinality: "one" }
+    }),
+    f("permission", "select", {
+      required: true,
+      selectOptions: ["view", "comment", "edit"],
+      defaultValue: "view"
+    }),
+    f("sharedBy", "relation", {
+      relation: { targetSchema: "core:Person", cardinality: "one" }
+    }),
+    f("createdAt", "date", { required: true })
+  ]
+};
+var person = {
+  "@id": "core:Person",
+  "@type": "trellis:Schema",
+  version: VERSION,
+  tier: "core",
+  subClassOf: "core:Thing",
+  label: "Person",
+  icon: "lucide:user",
+  fields: [f("name", "title", { required: true })]
+};
+var workflow = {
+  "@id": "core:Workflow",
+  "@type": "trellis:Schema",
+  version: VERSION,
+  tier: "core",
+  subClassOf: "core:Thing",
+  label: "Workflow",
+  icon: "lucide:git-branch",
+  fields: [
+    f("name", "title", { required: true }),
+    f("trigger", "rich_text"),
+    f("steps", "multi_select"),
+    f("active", "checkbox")
+  ]
+};
+var CORE_ONTOLOGY = [
+  thing,
+  record,
+  document,
+  event,
+  collection,
+  tag,
+  workspace,
+  app,
+  member,
+  notification,
+  share,
+  person,
+  workflow
+];
+
+// src/core/kernel/trellis-kernel.ts
 async function hashOp(kind, timestamp, agentId, previousHash, payload) {
   const data = `${kind}|${timestamp}|${agentId}|${previousHash ?? ""}|${payload}`;
   const buf = new TextEncoder().encode(data);
@@ -25,15 +311,26 @@ class TrellisKernel {
   snapshotThreshold;
   opsSinceSnapshot = 0;
   _booted = false;
+  ontologies = new Map;
+  workspaceConfig = null;
+  autoReplay = true;
   constructor(config) {
     this.store = new EAVStore;
     this.backend = config.backend;
     this.agentId = config.agentId;
     this.middleware = config.middleware ?? [];
     this.snapshotThreshold = config.snapshotThreshold ?? 0;
+    this.autoReplay = config.autoReplay ?? true;
+    for (const schema of CORE_ONTOLOGY) {
+      this.ontologies.set(schema["@id"], schema);
+    }
   }
   boot() {
     this.backend.init();
+    if (!this.autoReplay) {
+      this._booted = true;
+      return { opsReplayed: 0, fromSnapshot: false };
+    }
     let opsReplayed = 0;
     let fromSnapshot = false;
     const snapshot = this.backend.loadLatestSnapshot();
@@ -204,7 +501,7 @@ class TrellisKernel {
     const facts = this.store.getFactsByEntity(entityId);
     if (facts.length === 0)
       return null;
-    const typeFact = facts.find((f) => f.a === "type");
+    const typeFact = facts.find((f2) => f2.a === "type");
     return {
       id: entityId,
       type: typeFact?.v ?? "unknown",
@@ -217,11 +514,11 @@ class TrellisKernel {
     const deleteFacts = [];
     const addFacts = [];
     for (const [attr, newValue] of Object.entries(updates)) {
-      const existing = existingFacts.filter((f) => f.a === attr);
+      const existing = existingFacts.filter((f2) => f2.a === attr);
       deleteFacts.push(...existing);
       addFacts.push({ e: entityId, a: attr, v: newValue });
     }
-    const updatedAtFacts = existingFacts.filter((f) => f.a === "updatedAt");
+    const updatedAtFacts = existingFacts.filter((f2) => f2.a === "updatedAt");
     deleteFacts.push(...updatedAtFacts);
     addFacts.push({ e: entityId, a: "updatedAt", v: new Date().toISOString() });
     return this.mutate("addFacts", {
@@ -241,15 +538,15 @@ class TrellisKernel {
     let entityIds;
     if (type) {
       const typeFacts = this.store.getFactsByValue("type", type);
-      entityIds = new Set(typeFacts.map((f) => f.e));
+      entityIds = new Set(typeFacts.map((f2) => f2.e));
     } else {
       const allTypeFacts = this.store.getFactsByAttribute("type");
-      entityIds = new Set(allTypeFacts.map((f) => f.e));
+      entityIds = new Set(allTypeFacts.map((f2) => f2.e));
     }
     if (filters) {
       for (const [attr, value] of Object.entries(filters)) {
         const matchingFacts = this.store.getFactsByValue(attr, value);
-        const matchingEntities = new Set(matchingFacts.map((f) => f.e));
+        const matchingEntities = new Set(matchingFacts.map((f2) => f2.e));
         for (const id of entityIds) {
           if (!matchingEntities.has(id)) {
             entityIds.delete(id);
@@ -279,6 +576,163 @@ class TrellisKernel {
       deleteFacts: [{ e: entityId, a: attribute, v: value }]
     });
   }
+  getOntology(id) {
+    return this.ontologies.get(id);
+  }
+  listOntologies() {
+    return Array.from(this.ontologies.values());
+  }
+  createOntology(schema) {
+    const tier = schema.tier ?? "user";
+    if (tier === "core") {
+      throw new Error("Cannot modify core ontologies");
+    }
+    if (this.ontologies.has(schema["@id"])) {
+      throw new Error(`Ontology ${schema["@id"]} already exists`);
+    }
+    this.ontologies.set(schema["@id"], schema);
+    const fact = {
+      e: schema["@id"],
+      a: "schema",
+      v: JSON.stringify(schema)
+    };
+    this.store.addFacts([fact]);
+  }
+  updateOntology(id, updates) {
+    const existing = this.ontologies.get(id);
+    if (!existing) {
+      throw new Error(`Ontology ${id} not found`);
+    }
+    const tier = existing.tier ?? "user";
+    if (tier === "core") {
+      throw new Error("Cannot modify core ontologies");
+    }
+    const updated = { ...existing, ...updates };
+    this.ontologies.set(id, updated);
+    const existingFacts = this.store.getFactsByEntity(id);
+    const schemaFacts = existingFacts.filter((f2) => f2.a === "schema");
+    const deleteFacts = [...schemaFacts];
+    const addFacts = [
+      {
+        e: id,
+        a: "schema",
+        v: JSON.stringify(updated)
+      }
+    ];
+    this.store.deleteFacts(deleteFacts);
+    this.store.addFacts(addFacts);
+  }
+  deleteOntology(id) {
+    const existing = this.ontologies.get(id);
+    if (!existing) {
+      throw new Error(`Ontology ${id} not found`);
+    }
+    const tier = existing.tier ?? "user";
+    if (tier === "core") {
+      throw new Error("Cannot delete core ontologies");
+    }
+    this.ontologies.delete(id);
+    const facts = this.store.getFactsByEntity(id);
+    this.store.deleteFacts(facts);
+  }
+  bootWorkspace(config) {
+    this.workspaceConfig = config;
+    if (config.workspace.ontologies) {
+      for (const [id, schema] of Object.entries(config.workspace.ontologies)) {
+        if (!this.ontologies.has(id)) {
+          this.ontologies.set(id, schema);
+        }
+      }
+    }
+    if (config.workspace.graph?.nodes) {
+      for (const node of config.workspace.graph.nodes) {
+        const n = node;
+        if (n.id && n.type) {
+          const facts = [
+            { e: String(n.id), a: "type", v: String(n.type) }
+          ];
+          for (const [key, value] of Object.entries(n)) {
+            if (key !== "id" && key !== "type") {
+              facts.push({ e: String(n.id), a: key, v: value });
+            }
+          }
+          this.store.addFacts(facts);
+        }
+      }
+    }
+    if (config.workspace.graph?.edges) {
+      for (const edge of config.workspace.graph.edges) {
+        const e = edge;
+        if (e.source && e.target && e.relation) {
+          this.store.addLinks([
+            {
+              e1: String(e.source),
+              a: String(e.relation),
+              e2: String(e.target)
+            }
+          ]);
+        }
+      }
+    }
+    this.boot();
+  }
+  exportWorkspace() {
+    const ontologies = {};
+    for (const [id, schema] of this.ontologies) {
+      if (schema.tier !== "core") {
+        ontologies[id] = schema;
+      }
+    }
+    const allFacts = this.store.getAllFacts();
+    const nodes = [];
+    const entityIds = new Set(allFacts.map((f2) => f2.e));
+    for (const id of entityIds) {
+      const facts = this.store.getFactsByEntity(id);
+      const typeFact = facts.find((f2) => f2.a === "type");
+      const node = { id };
+      if (typeFact) {
+        node.type = typeFact.v;
+      }
+      for (const fact of facts) {
+        if (fact.a !== "type") {
+          node[fact.a] = fact.v;
+        }
+      }
+      nodes.push(node);
+    }
+    const allLinks = this.store.getAllLinks();
+    const edges = allLinks.map((l) => ({
+      source: l.e1,
+      relation: l.a,
+      target: l.e2
+    }));
+    return {
+      workspace: {
+        name: this.workspaceConfig?.workspace.name,
+        description: this.workspaceConfig?.workspace.description,
+        ontologies: Object.keys(ontologies).length > 0 ? ontologies : undefined,
+        graph: { nodes, edges },
+        projections: this.workspaceConfig?.workspace.projections,
+        routes: this.workspaceConfig?.workspace.routes,
+        app: this.workspaceConfig?.workspace.app
+      }
+    };
+  }
+  async createNode(id, data, type, _ctx) {
+    return this.createEntity(id, type, data);
+  }
+  async updateNode(id, data, type, _ctx) {
+    return this.updateEntity(id, data);
+  }
+  async deleteNode(id, _ctx) {
+    return this.deleteEntity(id);
+  }
+  async link(e1, a, e2, _ctx) {
+    return this.addLink(e1, a, e2);
+  }
+  async unlink(e1, a, e2, _ctx) {
+    return this.removeLink(e1, a, e2);
+  }
   addMiddleware(mw) {
     this.middleware.push(mw);
   }
@@ -456,6 +910,12 @@ class SqliteKernelBackend {
     const row = this._stmts.getLast.get();
     return row ? rowToOp(row) : undefined;
   }
+  getByHash(hash) {
+    return this.getOpByHash(hash);
+  }
+  getOpCount() {
+    return this.count();
+  }
   getOpByHash(hash) {
     const row = this._stmts.getByHash.get({ $hash: hash });
     return row ? rowToOp(row) : undefined;

package/dist/{index-xr7rx360.js → index-6n5dcebj.js}

@@ -496,6 +496,39 @@ async function route(req, url, path, auth, tenantId, ctx) {
       headers: { "Content-Type": "application/javascript" }
     });
   }
+  if (method === "GET" && path === "/__trellis/trellis.css") {
+    const candidates = [
+      join(import.meta.dir, "db", "trellis.css"),
+      join(import.meta.dir, "trellis.css")
+    ];
+    for (const p of candidates) {
+      if (existsSync(p)) {
+        return new Response(readFileSync(p, "utf-8"), {
+          headers: { "Content-Type": "text/css; charset=utf-8" }
+        });
+      }
+    }
+    return new Response("/* Trellis CSS not found */", {
+      headers: { "Content-Type": "text/css" }
+    });
+  }
+  if (method === "GET" && (path === "/" || path === "/inspector")) {
+    const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Trellis DB Inspector</title>
+  <link rel="stylesheet" href="/__trellis/trellis.css">
+</head>
+<body>
+  <script src="/__trellis/inspector.js"></script>
+</body>
+</html>`;
+    return new Response(html, {
+      headers: { "Content-Type": "text/html; charset=utf-8" }
+    });
+  }
   if (method === "GET" && path === "/health") {
     const kernel = ctx.pool.get(tenantId);
     const ops = kernel.readAllOps().length;

package/dist/{index-4beszbgg.js → index-7e27kvvj.js}

@@ -4,7 +4,7 @@ import {
 } from "./index-xzym9w0m.js";
 import {
   TenantPool
-} from "./index-5p6zgspx.js";
+} from "./index-y3d71wzd.js";
 import {
   __require
 } from "./index-a76rekgs.js";