trellis 2.1.7 → 3.0.2

package/dist/index-skhn0agf.js

@@ -0,0 +1,155 @@
+// @bun
+import {
+  init_eav_store,
+  jsonEntityFacts
+} from "./index-yhwjgfvj.js";
+import {
+  __require
+} from "./index-a76rekgs.js";
+
+// src/server/import.ts
+init_eav_store();
+import { readFileSync } from "fs";
+import { extname } from "path";
+async function importFile(kernel, filePath, opts) {
+  const ext = extname(filePath).toLowerCase();
+  switch (ext) {
+    case ".json":
+      return importJson(kernel, filePath, opts);
+    case ".ndjson":
+    case ".jsonl":
+      return importNdjson(kernel, filePath, opts);
+    case ".csv":
+    case ".tsv":
+      return importCsv(kernel, filePath, opts);
+    case ".parquet":
+      return importParquet(kernel, filePath, opts);
+    default:
+      throw new Error(`Unsupported file format: ${ext}. Supported: .json, .ndjson, .jsonl, .csv, .tsv, .parquet`);
+  }
+}
+async function importRecords(kernel, records, opts) {
+  return _ingestRows(kernel, records, opts);
+}
+async function importJson(kernel, filePath, opts) {
+  const raw = readFileSync(filePath, "utf8");
+  const parsed = JSON.parse(raw);
+  const rows = Array.isArray(parsed) ? parsed : [parsed];
+  return _ingestRows(kernel, rows, opts);
+}
+async function importNdjson(kernel, filePath, opts) {
+  const raw = readFileSync(filePath, "utf8");
+  const rows = raw.split(`
+`).map((l) => l.trim()).filter(Boolean).map((line, i) => {
+    try {
+      return JSON.parse(line);
+    } catch {
+      return null;
+    }
+  }).filter(Boolean);
+  return _ingestRows(kernel, rows, opts);
+}
+async function importCsv(kernel, filePath, opts) {
+  const raw = readFileSync(filePath, "utf8");
+  const sep = filePath.endsWith(".tsv") ? "\t" : ",";
+  const rows = parseCsv(raw, sep);
+  return _ingestRows(kernel, rows, opts);
+}
+function parseCsv(raw, sep = ",") {
+  const lines = raw.split(/\r?\n/);
+  if (lines.length < 2)
+    return [];
+  const headers = splitCsvLine(lines[0], sep);
+  const result = [];
+  for (let i = 1;i < lines.length; i++) {
+    const line = lines[i];
+    if (!line || line.trim() === "")
+      continue;
+    const values = splitCsvLine(line, sep);
+    const row = {};
+    headers.forEach((h, idx) => {
+      row[h] = values[idx] ?? "";
+    });
+    result.push(row);
+  }
+  return result;
+}
+function splitCsvLine(line, sep) {
+  const result = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0;i < line.length; i++) {
+    const ch = line[i];
+    if (ch === '"') {
+      if (inQuotes && line[i + 1] === '"') {
+        current += '"';
+        i++;
+      } else {
+        inQuotes = !inQuotes;
+      }
+    } else if (ch === sep && !inQuotes) {
+      result.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  result.push(current);
+  return result;
+}
+async function importParquet(kernel, filePath, opts) {
+  let parquet;
+  try {
+    parquet = await import("parquetjs");
+  } catch {
+    try {
+      parquet = await import("@dsnp/parquetjs");
+    } catch {
+      throw new Error("Parquet support requires `parquetjs` or `@dsnp/parquetjs`.\nRun: bun add parquetjs");
+    }
+  }
+  const reader = await parquet.ParquetReader.openFile(filePath);
+  const cursor = reader.getCursor();
+  const rows = [];
+  let row;
+  while ((row = await cursor.next()) !== null) {
+    rows.push(row);
+  }
+  await reader.close();
+  return _ingestRows(kernel, rows, opts);
+}
+async function _ingestRows(kernel, rows, opts) {
+  const result = {
+    imported: 0,
+    skipped: 0,
+    errors: [],
+    entityIds: []
+  };
+  const limit = opts.limit ?? Infinity;
+  let count = 0;
+  for (let i = 0;i < rows.length; i++) {
+    if (count >= limit)
+      break;
+    const row = rows[i];
+    if (!row || opts.skipEmpty && Object.keys(row).length === 0) {
+      result.skipped++;
+      continue;
+    }
+    try {
+      const entityId = opts.idField ? `${opts.idPrefix ?? "import:"}${String(row[opts.idField] ?? "")}` : `${opts.idPrefix ?? "import:"}${crypto.randomUUID()}`;
+      const facts = jsonEntityFacts(entityId, row, opts.type);
+      await kernel.mutate("addFacts", { facts });
+      result.imported++;
+      result.entityIds.push(entityId);
+      count++;
+    } catch (err) {
+      result.errors.push({
+        row: i,
+        message: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return result;
+}
+
+export { importFile, importRecords };

package/dist/{index-5m0g9r0y.js → index-w7ng765c.js}

@@ -1,499 +1,4 @@
 // @bun
-import {
-  QueryEngine,
-  literal,
-  variable
-} from "./index-hybgxe40.js";
-
-// src/core/query/parser.ts
-function tokenize(input) {
-  const tokens = [];
-  let i = 0;
-  while (i < input.length) {
-    if (/\s/.test(input[i])) {
-      i++;
-      continue;
-    }
-    if (input[i] === "/" && input[i + 1] === "/") {
-      while (i < input.length && input[i] !== `
-`)
-        i++;
-      continue;
-    }
-    const pos = i;
-    if ("[](){},:".includes(input[i])) {
-      tokens.push({ kind: "symbol", value: input[i], pos });
-      i++;
-      continue;
-    }
-    if (input[i] === "!" && input[i + 1] === "=") {
-      tokens.push({ kind: "symbol", value: "!=", pos });
-      i += 2;
-      continue;
-    }
-    if (input[i] === "<" && input[i + 1] === "=") {
-      tokens.push({ kind: "symbol", value: "<=", pos });
-      i += 2;
-      continue;
-    }
-    if (input[i] === ">" && input[i + 1] === "=") {
-      tokens.push({ kind: "symbol", value: ">=", pos });
-      i += 2;
-      continue;
-    }
-    if ("<>=".includes(input[i])) {
-      tokens.push({ kind: "symbol", value: input[i], pos });
-      i++;
-      continue;
-    }
-    if (input[i] === '"') {
-      i++;
-      let s = "";
-      while (i < input.length && input[i] !== '"') {
-        if (input[i] === "\\" && i + 1 < input.length) {
-          s += input[i + 1];
-          i += 2;
-        } else {
-          s += input[i];
-          i++;
-        }
-      }
-      if (i < input.length)
-        i++;
-      tokens.push({ kind: "string", value: s, pos });
-      continue;
-    }
-    if (/[0-9]/.test(input[i]) || input[i] === "-" && i + 1 < input.length && /[0-9]/.test(input[i + 1])) {
-      let n = input[i];
-      i++;
-      while (i < input.length && /[0-9.]/.test(input[i])) {
-        n += input[i];
-        i++;
-      }
-      tokens.push({ kind: "number", value: n, pos });
-      continue;
-    }
-    if (/[?a-zA-Z_]/.test(input[i])) {
-      let w = "";
-      while (i < input.length && /[?a-zA-Z0-9_.:/-]/.test(input[i])) {
-        w += input[i];
-        i++;
-      }
-      tokens.push({ kind: "word", value: w, pos });
-      continue;
-    }
-    i++;
-  }
-  tokens.push({ kind: "eof", value: "", pos: input.length });
-  return tokens;
-}
-
-class Parser {
-  tokens;
-  pos = 0;
-  constructor(tokens) {
-    this.tokens = tokens;
-  }
-  peek() {
-    return this.tokens[this.pos];
-  }
-  advance() {
-    return this.tokens[this.pos++];
-  }
-  expect(kind, value) {
-    const t = this.advance();
-    if (t.kind !== kind || value !== undefined && t.value !== value) {
-      throw new Error(`Expected ${kind}${value ? ` "${value}"` : ""} at pos ${t.pos}, got ${t.kind} "${t.value}"`);
-    }
-    return t;
-  }
-  match(kind, value) {
-    const t = this.peek();
-    if (t.kind === kind && (value === undefined || t.value === value)) {
-      this.pos++;
-      return true;
-    }
-    return false;
-  }
-  isAt(kind, value) {
-    const t = this.peek();
-    return t.kind === kind && (value === undefined || t.value === value);
-  }
-  parseTerm() {
-    const t = this.peek();
-    if (t.kind === "word" && t.value.startsWith("?")) {
-      this.advance();
-      return variable(t.value.slice(1));
-    }
-    if (t.kind === "string") {
-      this.advance();
-      return literal(t.value);
-    }
-    if (t.kind === "number") {
-      this.advance();
-      const n = Number(t.value);
-      return literal(n);
-    }
-    if (t.kind === "word") {
-      const v = t.value;
-      this.advance();
-      if (v === "true")
-        return literal(true);
-      if (v === "false")
-        return literal(false);
-      return literal(v);
-    }
-    throw new Error(`Unexpected token at pos ${t.pos}: ${t.kind} "${t.value}"`);
-  }
-  parsePattern() {
-    const t = this.peek();
-    if (t.kind === "word" && t.value.toUpperCase() === "NOT") {
-      this.advance();
-      const inner = this.parsePattern();
-      return { kind: "not", pattern: inner };
-    }
-    if (t.kind === "word" && t.value.toUpperCase() === "OR") {
-      this.advance();
-      const branches = [];
-      while (this.isAt("symbol", "{")) {
-        this.advance();
-        const branch = [];
-        while (!this.isAt("symbol", "}") && !this.isAt("eof", undefined)) {
-          branch.push(this.parsePattern());
-        }
-        this.expect("symbol", "}");
-        branches.push(branch);
-      }
-      return { kind: "or", branches };
-    }
-    if (t.kind === "symbol" && t.value === "[") {
-      this.advance();
-      const entity = this.parseTerm();
-      const attribute = this.parseTerm();
-      const value = this.parseTerm();
-      this.expect("symbol", "]");
-      return { kind: "fact", entity, attribute, value };
-    }
-    if (t.kind === "symbol" && t.value === "(") {
-      this.advance();
-      const source = this.parseTerm();
-      const attribute = this.parseTerm();
-      const target = this.parseTerm();
-      this.expect("symbol", ")");
-      return { kind: "link", source, attribute, target };
-    }
-    if (t.kind === "word" && !t.value.startsWith("?")) {
-      const name = this.advance().value;
-      if (this.isAt("symbol", "(")) {
-        this.advance();
-        const args = [];
-        while (!this.isAt("symbol", ")") && !this.isAt("eof", undefined)) {
-          args.push(this.parseTerm());
-          this.match("symbol", ",");
-        }
-        this.expect("symbol", ")");
-        return { kind: "rule", name, args };
-      }
-      throw new Error(`Expected '(' after rule name "${name}" at pos ${t.pos}`);
-    }
-    throw new Error(`Cannot parse pattern at pos ${t.pos}: ${t.kind} "${t.value}"`);
-  }
-  parseFilter() {
-    const left = this.parseTerm();
-    const op = this.advance().value;
-    const right = this.parseTerm();
-    return { kind: "filter", left, op, right };
-  }
-  parseQuery() {
-    const query = {
-      select: [],
-      where: [],
-      filters: [],
-      aggregates: [],
-      orderBy: [],
-      limit: 0,
-      offset: 0
-    };
-    while (!this.isAt("eof", undefined)) {
-      const kw = this.peek();
-      if (kw.kind !== "word") {
-        throw new Error(`Expected keyword at pos ${kw.pos}, got ${kw.kind} "${kw.value}"`);
-      }
-      switch (kw.value.toUpperCase()) {
-        case "SELECT": {
-          this.advance();
-          while (this.peek().kind === "word" && this.peek().value.startsWith("?")) {
-            query.select.push(this.advance().value.slice(1));
-          }
-          break;
-        }
-        case "WHERE": {
-          this.advance();
-          this.expect("symbol", "{");
-          while (!this.isAt("symbol", "}") && !this.isAt("eof", undefined)) {
-            query.where.push(this.parsePattern());
-          }
-          this.expect("symbol", "}");
-          break;
-        }
-        case "FILTER": {
-          this.advance();
-          query.filters.push(this.parseFilter());
-          break;
-        }
-        case "AGGREGATE": {
-          this.advance();
-          const op = this.advance().value;
-          this.expect("symbol", "(");
-          const varName = this.advance().value;
-          const varClean = varName.startsWith("?") ? varName.slice(1) : varName;
-          this.expect("symbol", ")");
-          this.expect("word", "AS");
-          const asName = this.advance().value;
-          const asClean = asName.startsWith("?") ? asName.slice(1) : asName;
-          query.aggregates.push({ op, variable: varClean, as: asClean });
-          break;
-        }
-        case "ORDER": {
-          this.advance();
-          this.expect("word", "BY");
-          while (this.peek().kind === "word" && this.peek().value.startsWith("?")) {
-            const v = this.advance().value.slice(1);
-            let dir = "asc";
-            if (this.peek().kind === "word" && ["ASC", "DESC"].includes(this.peek().value.toUpperCase())) {
-              dir = this.advance().value.toLowerCase();
-            }
-            query.orderBy.push({ variable: v, direction: dir });
-          }
-          break;
-        }
-        case "LIMIT": {
-          this.advance();
-          query.limit = Number(this.expect("number").value);
-          break;
-        }
-        case "OFFSET": {
-          this.advance();
-          query.offset = Number(this.expect("number").value);
-          break;
-        }
-        default:
-          throw new Error(`Unknown keyword "${kw.value}" at pos ${kw.pos}`);
-      }
-    }
-    return query;
-  }
-  parseRule() {
-    const name = this.expect("word").value;
-    this.expect("symbol", "(");
-    const params = [];
-    while (!this.isAt("symbol", ")") && !this.isAt("eof", undefined)) {
-      const v = this.expect("word").value;
-      params.push(v.startsWith("?") ? v.slice(1) : v);
-      this.match("symbol", ",");
-    }
-    this.expect("symbol", ")");
-    if (this.isAt("symbol", ":")) {
-      this.advance();
-      if (this.peek().kind === "number" && this.peek().value.startsWith("-")) {
-        this.advance();
-      }
-    } else if (this.isAt("word", ":-")) {
-      this.advance();
-    }
-    const body = [];
-    const filters = [];
-    while (!this.isAt("eof", undefined)) {
-      if (this.peek().kind === "word" && this.peek().value.toUpperCase() === "FILTER") {
-        this.advance();
-        filters.push(this.parseFilter());
-      } else {
-        body.push(this.parsePattern());
-      }
-      this.match("symbol", ",");
-    }
-    return { name, params, body, filters };
-  }
-}
-function parseQuery(input) {
-  const tokens = tokenize(input);
-  return new Parser(tokens).parseQuery();
-}
-function parseRule(input) {
-  const tokens = tokenize(input);
-  return new Parser(tokens).parseRule();
-}
-function parseSimple(input) {
-  const trimmed = input.trim();
-  const upper = trimmed.toUpperCase();
-  if (upper.startsWith("SELECT") || upper.startsWith("WHERE")) {
-    return parseQuery(trimmed);
-  }
-  const findMatch = trimmed.match(/^find\s+(.+?)\s+where\s+(.+)$/i);
-  if (findMatch) {
-    const vars = findMatch[1].trim().split(/\s+/);
-    const conditions = findMatch[2].trim();
-    const selectVars = vars.map((v) => v.startsWith("?") ? v : `?${v}`);
-    const entity = selectVars[0];
-    const parts = conditions.split(/\s+and\s+/i);
-    const patterns = [];
-    const filters = [];
-    for (const part of parts) {
-      const eqMatch = part.match(/^(\S+)\s*(=|!=|<|<=|>|>=|contains|startsWith|endsWith|matches)\s*(.+)$/);
-      if (eqMatch) {
-        const [, attr, op, val] = eqMatch;
-        const valTrimmed = val.trim();
-        if (op === "=") {
-          patterns.push(`[${entity} "${attr}" ${valTrimmed}]`);
-        } else {
-          const tmpVar = `?_${attr.replace(/[^a-zA-Z0-9]/g, "_")}`;
-          patterns.push(`[${entity} "${attr}" ${tmpVar}]`);
-          filters.push(`FILTER ${tmpVar} ${op} ${valTrimmed}`);
-        }
-      }
-    }
-    const fullQuery = `SELECT ${selectVars.join(" ")}
-WHERE {
-  ${patterns.join(`
-  `)}
-}
-${filters.join(`
-`)}`;
-    return parseQuery(fullQuery);
-  }
-  throw new Error(`Cannot parse query: "${trimmed}". Use full EQL-S syntax or "find ?e where attr = value".`);
-}
-
-// src/core/query/datalog.ts
-function transitiveClosureRules(ruleName, linkAttribute) {
-  return [
-    {
-      name: ruleName,
-      params: ["x", "y"],
-      body: [
-        {
-          kind: "link",
-          source: variable("x"),
-          attribute: literal(linkAttribute),
-          target: variable("y")
-        }
-      ],
-      filters: []
-    },
-    {
-      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: []
-    }
-  ];
-}
-function reverseReachabilityRules(ruleName, linkAttribute) {
-  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: []
-    }
-  ];
-}
-function siblingRules(ruleName, linkAttribute) {
-  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")
-        }
-      ]
-    }
-  ];
-}
-
-class DatalogRuntime {
-  engine;
-  constructor(store) {
-    this.engine = new QueryEngine(store);
-  }
-  addRule(rule) {
-    this.engine.addRule(rule);
-  }
-  addRules(rules) {
-    for (const r of rules)
-      this.engine.addRule(r);
-  }
-  removeRule(name) {
-    this.engine.removeRule(name);
-  }
-  registerTransitiveClosure(ruleName, linkAttribute) {
-    this.addRules(transitiveClosureRules(ruleName, linkAttribute));
-  }
-  registerReverseReachability(ruleName, linkAttribute) {
-    this.addRules(reverseReachabilityRules(ruleName, linkAttribute));
-  }
-  registerSiblings(ruleName, linkAttribute) {
-    this.addRules(siblingRules(ruleName, linkAttribute));
-  }
-  getEngine() {
-    return this.engine;
-  }
-}
 // src/core/ontology/registry.ts
 class OntologyRegistry {
   schemas = new Map;
@@ -786,7 +291,9 @@ var agentOntology = {
         { name: "status", type: "string", enum: ["running", "completed", "failed", "cancelled"], default: "running" },
         { name: "input", type: "string" },
         { name: "output", type: "string" },
-        { name: "tokenCount", type: "number" }
+        { name: "totalTokens", type: "number" },
+        { name: "promptTokens", type: "number" },
+        { name: "completionTokens", type: "number" }
       ]
     },
     {
@@ -1097,4 +604,4 @@ function createValidationMiddleware(registry, options) {
     }
   };
 }
-export { parseQuery, parseRule, parseSimple, DatalogRuntime, OntologyRegistry, projectOntology, teamOntology, agentOntology, builtinOntologies, validateEntity, validateStore, createValidationMiddleware };
+export { OntologyRegistry, projectOntology, teamOntology, agentOntology, builtinOntologies, validateEntity, validateStore, createValidationMiddleware };