@dxos/assistant 0.8.0 → 0.8.1-main.81238a8

package/dist/lib/node/chunk-QPHGQINW.cjs

@@ -1,577 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var chunk_QPHGQINW_exports = {};
-__export(chunk_QPHGQINW_exports, {
-  EchoDataSource: () => EchoDataSource,
-  executeQuery: () => executeQuery,
-  executeQueryPlan: () => executeQueryPlan,
-  formatInferredRelationshipLabel: () => formatInferredRelationshipLabel,
-  formatJsonSchemaForLLM: () => formatJsonSchemaForLLM,
-  formatNodeLabel: () => formatNodeLabel,
-  isReference: () => isReference,
-  parseCypherQuery: () => parseCypherQuery,
-  trim: () => trim
-});
-module.exports = __toCommonJS(chunk_QPHGQINW_exports);
-var import_parjs = require("#parjs");
-var import_log = require("@dxos/log");
-var import_util = require("@dxos/util");
-var import_invariant = require("@dxos/invariant");
-var import_log2 = require("@dxos/log");
-var import_debug = require("@dxos/debug");
-var import_echo_schema = require("@dxos/echo-schema");
-var import_debug2 = require("@dxos/debug");
-var import_echo_db = require("@dxos/echo-db");
-var import_echo_schema2 = require("@dxos/echo-schema");
-var import_live_object = require("@dxos/live-object");
-var import_log3 = require("@dxos/log");
-var ws = import_parjs.parjs.whitespace();
-var nothing = import_parjs.parjs.string("").pipe(import_parjs.parjsCombinators.map(() => null));
-var optional = (parser) => parser.pipe(import_parjs.parjsCombinators.recover(() => ({
-  kind: "Soft"
-})), import_parjs.parjsCombinators.or(nothing));
-var keyword = (word) => import_parjs.parjs.string(word).pipe(import_parjs.parjsCombinators.map(() => word));
-var identifier = import_parjs.parjs.regexp(/[a-zA-Z_][a-zA-Z0-9_]*/).pipe(import_parjs.parjsCombinators.map((match) => ({
-  astKind: "Identifier",
-  name: match[0]
-})));
-var numberLiteral = import_parjs.parjs.regexp(/-?\d+(\.\d+)?/).pipe(import_parjs.parjsCombinators.map(Number));
-var stringLiteral = import_parjs.parjs.regexp(/"([^"]*)"|'([^']*)'/).pipe(import_parjs.parjsCombinators.map((match) => ({
-  astKind: "StringLiteral",
-  value: match[1] || match[2]
-})));
-var variableTag = identifier.pipe(import_parjs.parjsCombinators.map((variable) => variable)).expects("variable tag");
-var label = identifier.pipe(import_parjs.parjsCombinators.map((name) => name));
-var property = identifier.pipe(import_parjs.parjsCombinators.then(import_parjs.parjs.string(":"), ws, stringLiteral), import_parjs.parjsCombinators.map(([key, , , value]) => ({
-  key,
-  value
-})));
-var properties = property.pipe(import_parjs.parjsCombinators.manySepBy(","), import_parjs.parjsCombinators.between("{", "}"), import_parjs.parjsCombinators.map((properties2) => ({
-  astKind: "Properties",
-  properties: properties2
-})));
-var nodePattern = optional(variableTag).pipe(import_parjs.parjsCombinators.then(":"), import_parjs.parjsCombinators.then(ws, label, ws), import_parjs.parjsCombinators.then(optional(properties)), import_parjs.parjsCombinators.between("(", ")"), import_parjs.parjsCombinators.map(([[[variable], _, label2], properties2]) => ({
-  astKind: "NodePattern",
-  variable,
-  label: label2,
-  properties: properties2
-})));
-var relationshipPattern = optional(variableTag).pipe(import_parjs.parjsCombinators.then(":"), import_parjs.parjsCombinators.then(ws, label, ws), import_parjs.parjsCombinators.then(optional(properties)), import_parjs.parjsCombinators.between("[", "]"), import_parjs.parjsCombinators.map(([[[variable], _, label2], properties2]) => ({
-  astKind: "RelationshipPattern",
-  variable,
-  label: label2,
-  properties: properties2
-})));
-var graphPatternConnector = import_parjs.parjs.string("->").pipe(import_parjs.parjsCombinators.or("<-", "-"), import_parjs.parjsCombinators.map((x) => ({
-  astKind: "GraphPatternConnector",
-  direction: x
-})));
-var graphPattern = nodePattern.pipe(import_parjs.parjsCombinators.or(relationshipPattern), import_parjs.parjsCombinators.manySepBy(graphPatternConnector), import_parjs.parjsCombinators.map((segments) => ({
-  astKind: "GraphPattern",
-  segments
-})));
-var matchClause = keyword("MATCH").pipe(import_parjs.parjsCombinators.then(ws), import_parjs.parjsCombinators.then(graphPattern), import_parjs.parjsCombinators.map(([, pattern]) => ({
-  astKind: "MatchClause",
-  pattern
-})));
-var memberExpression = identifier.pipe(import_parjs.parjsCombinators.manySepBy("."), import_parjs.parjsCombinators.map((path) => ({
-  astKind: "MemberExpression",
-  path
-})));
-var equalsPredicate = memberExpression.pipe(import_parjs.parjsCombinators.then(ws, import_parjs.parjs.string("="), ws, stringLiteral), import_parjs.parjsCombinators.map(([left, , , , right]) => ({
-  astKind: "EqualsPredicate",
-  left,
-  right
-})));
-var whereClause = keyword("WHERE").pipe(import_parjs.parjsCombinators.then(ws, equalsPredicate.pipe(import_parjs.parjsCombinators.between(ws, ws), import_parjs.parjsCombinators.manySepBy(import_parjs.parjs.string("AND"))), ws), import_parjs.parjsCombinators.map(([, , predicates]) => ({
-  astKind: "WhereClause",
-  predicates
-})));
-var returnClause = keyword("RETURN").pipe(import_parjs.parjsCombinators.then(ws, memberExpression.pipe(import_parjs.parjsCombinators.then(optional(import_parjs.parjs.string("AS").pipe(import_parjs.parjsCombinators.between(ws), import_parjs.parjsCombinators.then(identifier))), ws), import_parjs.parjsCombinators.manySepBy(import_parjs.parjs.string(",").pipe(import_parjs.parjsCombinators.then(ws)))), ws), import_parjs.parjsCombinators.map(([, , fields]) => ({
-  astKind: "ReturnClause",
-  fields: fields.map(([f]) => f)
-})));
-var cypherQuery = ws.pipe(import_parjs.parjsCombinators.then(matchClause, ws, optional(whereClause), ws, returnClause, ws), import_parjs.parjsCombinators.map(([, matchClause2, , whereClause2, , returnClause2]) => ({
-  astKind: "CypherQuery",
-  matchClause: matchClause2,
-  whereClause: whereClause2,
-  returnClause: returnClause2
-})));
-var parseCypherQuery = (query) => {
-  const parseResult = cypherQuery.parse(query);
-  if (parseResult.isOk) {
-    return {
-      ast: parseResult.value
-    };
-  } else {
-    throw new Error(`Failed to parse query: ${parseResult}`);
-  }
-};
-var __dxlog_file = "/home/runner/work/dxos/dxos/packages/experimental/assistant/src/cypher/execution-plan.ts";
-var createExecutionPlan = (query) => {
-  return new ExecutionPlanBuilder().build(query);
-};
-var ExecutionPlanBuilder = class {
-  constructor() {
-    this.counter = 0;
-  }
-  newVariable() {
-    return `anon_${this.counter++}`;
-  }
-  build(query) {
-    (0, import_log2.log)("Creating execution plan for query", {
-      query
-    }, {
-      F: __dxlog_file,
-      L: 76,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    return {
-      steps: [
-        ...this.createStepsForMatchClause(query.ast.matchClause),
-        ...query.ast.whereClause ? this.createStepsForWhereClause(query.ast.whereClause) : [],
-        ...this.createStepsForReturnClause(query.ast.returnClause)
-      ],
-      output: {
-        fields: this.getOutputFields(query.ast.returnClause)
-      }
-    };
-  }
-  createStepsForMatchClause(match) {
-    (0, import_invariant.invariant)(match.pattern.segments.length > 0, void 0, {
-      F: __dxlog_file,
-      L: 90,
-      S: this,
-      A: [
-        "match.pattern.segments.length > 0",
-        ""
-      ]
-    });
-    const firstSegment = match.pattern.segments[0];
-    (0, import_invariant.invariant)(firstSegment.astKind === "NodePattern", void 0, {
-      F: __dxlog_file,
-      L: 92,
-      S: this,
-      A: [
-        "firstSegment.astKind === 'NodePattern'",
-        ""
-      ]
-    });
-    let lastNodeVariable = firstSegment.variable?.name ?? this.newVariable();
-    const steps = [];
-    steps.push({
-      type: "NodeScan",
-      label: firstSegment.label.name,
-      into: lastNodeVariable
-    });
-    if (firstSegment.properties) {
-      for (const property2 of firstSegment.properties.properties) {
-        steps.push({
-          type: "FilterByProperty",
-          variable: lastNodeVariable,
-          property: property2.key.name,
-          value: property2.value.value
-        });
-      }
-    }
-    for (let i = 1; i < match.pattern.segments.length; i++) {
-      const relationshipSegment = match.pattern.segments[i++];
-      (0, import_invariant.invariant)(relationshipSegment.astKind === "RelationshipPattern", void 0, {
-        F: __dxlog_file,
-        L: 115,
-        S: this,
-        A: [
-          "relationshipSegment.astKind === 'RelationshipPattern'",
-          ""
-        ]
-      });
-      const nodeSegment = match.pattern.segments[i];
-      (0, import_invariant.invariant)(nodeSegment.astKind === "NodePattern", void 0, {
-        F: __dxlog_file,
-        L: 117,
-        S: this,
-        A: [
-          "nodeSegment.astKind === 'NodePattern'",
-          ""
-        ]
-      });
-      const leftSeparator = match.pattern.segments.separators[i - 2];
-      const rightSeparator = match.pattern.segments.separators[i - 1];
-      const direction = getDirection(leftSeparator.direction, rightSeparator.direction);
-      const relationshipVariable = relationshipSegment.variable?.name ?? this.newVariable();
-      const nodeVariable = nodeSegment.variable?.name ?? this.newVariable();
-      steps.push({
-        type: "RelationshipScan",
-        label: relationshipSegment.label.name,
-        direction,
-        anchor: lastNodeVariable,
-        relationshipInto: relationshipVariable,
-        nodeInto: nodeVariable
-      });
-      if (relationshipSegment.properties) {
-        for (const property2 of relationshipSegment.properties.properties) {
-          steps.push({
-            type: "FilterByProperty",
-            variable: relationshipVariable,
-            property: property2.key.name,
-            value: property2.value.value
-          });
-        }
-      }
-      if (nodeSegment.label) {
-        steps.push({
-          type: "FilterByLabel",
-          variable: nodeVariable,
-          label: nodeSegment.label.name
-        });
-      }
-      if (nodeSegment.properties) {
-        for (const property2 of nodeSegment.properties.properties) {
-          steps.push({
-            type: "FilterByProperty",
-            variable: nodeVariable,
-            property: property2.key.name,
-            value: property2.value.value
-          });
-        }
-      }
-      lastNodeVariable = nodeVariable;
-    }
-    return steps;
-  }
-  createStepsForWhereClause(where) {
-    return [];
-  }
-  createStepsForReturnClause(returnClause2) {
-    return [
-      {
-        type: "ProduceResults",
-        fields: returnClause2.fields.map((field) => ({
-          name: field.path.map((p) => p.name).join("_"),
-          variable: field.path[0].name,
-          path: field.path.length > 1 ? field.path.slice(1).map((p) => p.name).join(".") : "$"
-        }))
-      }
-    ];
-  }
-  getOutputFields(returnClause2) {
-    return returnClause2.fields.map((field) => field.path.map((p) => p.name).join("_"));
-  }
-};
-var getDirection = (left, right) => {
-  if (left === "-" && right === "->") {
-    return "out";
-  } else if (left === "<-" && right === "-") {
-    return "in";
-  } else if (left === "-" && right === "-") {
-    return "both";
-  }
-  throw new Error(`Invalid direction: ()${left}[]${right}()`);
-};
-var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/experimental/assistant/src/cypher/query-executor.ts";
-var executeQueryPlan = async (dataSource, plan) => {
-  let buffer = [];
-  const results = [];
-  for (const step of plan.steps) {
-    (0, import_log.log)("begin step", {
-      step
-    }, {
-      F: __dxlog_file2,
-      L: 41,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-    switch (step.type) {
-      case "NodeScan": {
-        const nodes = await dataSource.getNodes({
-          label: step.label
-        });
-        buffer.push(...nodes.map((node) => ({
-          [step.into]: node
-        })));
-        break;
-      }
-      case "FilterByLabel": {
-        buffer = buffer.filter((item) => {
-          const node = item[step.variable];
-          return node && node.kind === "node" && node.label === step.label;
-        });
-        break;
-      }
-      case "FilterByProperty": {
-        buffer = buffer.filter((item) => {
-          const node = item[step.variable];
-          return node && node.kind === "node" && node.properties[step.property] === step.value;
-        });
-        break;
-      }
-      case "RelationshipScan": {
-        const relationships = await dataSource.getRelationships({
-          label: step.label
-        });
-        for (const tuple of [
-          ...buffer
-        ]) {
-          if (tuple[step.anchor].kind !== "node") {
-            continue;
-          }
-          const filteredRelationships = relationships.filter((relationship) => {
-            switch (step.direction) {
-              case "in":
-                return relationship.target.id === tuple[step.anchor].id;
-              case "out":
-                return relationship.source.id === tuple[step.anchor].id;
-              case "both":
-                return relationship.source.id === tuple[step.anchor].id || relationship.target.id === tuple[step.anchor].id;
-              default:
-                throw new Error(`Unknown direction: ${step.direction}`);
-            }
-          });
-          for (let i = 0; i < filteredRelationships.length; i++) {
-            const relationship = filteredRelationships[i];
-            const newTuple = i === 0 ? tuple : {
-              ...tuple
-            };
-            if (newTuple !== tuple) {
-              buffer.push(newTuple);
-            }
-            newTuple[step.relationshipInto] = relationship;
-            switch (step.direction) {
-              case "in":
-                newTuple[step.nodeInto] = relationship.source;
-                break;
-              case "out":
-                newTuple[step.nodeInto] = relationship.target;
-                break;
-              case "both":
-                newTuple[step.nodeInto] = relationship.source.id === newTuple[step.anchor].id ? relationship.target : relationship.source;
-                break;
-            }
-          }
-        }
-        break;
-      }
-      case "ProduceResults": {
-        for (const tuple of buffer) {
-          const result = {};
-          for (const field of step.fields) {
-            result[field.name] = jsonPathGet(tuple[field.variable].properties, field.path);
-          }
-          results.push(result);
-        }
-        break;
-      }
-    }
-    (0, import_log.log)("finish step", {
-      buffer: buffer.map((tuple) => (0, import_util.mapValues)(tuple, (x) => x.id)),
-      results
-    }, {
-      F: __dxlog_file2,
-      L: 118,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-  }
-  return results;
-};
-var executeQuery = (dataSource, query) => {
-  const plan = createExecutionPlan(parseCypherQuery(query));
-  return executeQueryPlan(dataSource, plan);
-};
-var jsonPathGet = (obj, path) => {
-  if (path === "" || path === "$") {
-    return obj;
-  }
-  const parts = path.split(".");
-  if (parts[0] === "$") {
-    parts.shift();
-  }
-  let result = obj;
-  for (const part of parts) {
-    result = result?.[part];
-  }
-  return result;
-};
-var trim = (strings, ...values) => {
-  const combined = strings.reduce((acc, str, i) => {
-    return acc + str + (values[i] || "");
-  }, "");
-  return combined.replace("/^\n/", "").replace(/\n$/, "");
-};
-var formatJsonSchemaForLLM = (schemaTypes) => {
-  return schemaTypes.flatMap((schema) => [
-    formatNodeSchema(schema),
-    ...formatInferredRelationships(schema, schemaTypes)
-  ]);
-};
-var formatNodeSchema = (schema) => {
-  const label2 = formatNodeLabel(schema.typename ?? (0, import_debug.raise)(new Error("Schema must have $id")));
-  const properties2 = Object.entries(schema.properties).filter(([key, prop]) => key !== "id" && !isReference(prop));
-  return trim`
-    <node>
-      (:${label2})
-
-      <description>${schema.description}</description>
-
-      <properties>
-        ${properties2.map(([key, value]) => {
-    return trim`
-            <${key}>
-              <type>${value.type}</type>
-              <description>${value.description}</description>
-            </${key}>
-          `;
-  })}
-      </properties>
-    </node>
-  `;
-};
-var formatInferredRelationships = (schema, allSchema) => {
-  const nodeLabel = formatNodeLabel(schema.typename ?? (0, import_debug.raise)(new Error("Schema must have $id")));
-  const relationships = Object.entries(schema.properties).filter(([key, prop]) => isReference(prop));
-  return relationships.map(([key, value]) => {
-    const relationshipLabel = formatInferredRelationshipLabel(schema.typename ?? (0, import_debug.raise)(new Error("Schema must have $id")), key);
-    const targetSchema = allSchema.find((schema2) => `dxn:type/${schema2.typename}` === value.reference?.schema.$ref);
-    const targetLabel = targetSchema ? formatNodeLabel(targetSchema?.typename ?? "") : "";
-    return trim`
-      <relationship>
-        (:${nodeLabel})-[:${relationshipLabel}]->(:${targetLabel})
-
-        <description>${value.description}</description>
-      </relationship>
-    `;
-  });
-};
-var formatNodeLabel = (typename) => {
-  return typename.replace(/^example\.com\/type\//g, "");
-};
-var formatInferredRelationshipLabel = (typename, property2) => {
-  const nodeLabel = formatNodeLabel(typename);
-  return `${nodeLabel}_${property2}`.toUpperCase();
-};
-var isReference = (schema) => schema.$id === import_echo_schema.JSON_SCHEMA_ECHO_REF_ID || schema.type === "array" && !Array.isArray(schema.items) && typeof schema.items === "object" && "$id" in schema.items && schema.items.$id === import_echo_schema.JSON_SCHEMA_ECHO_REF_ID;
-function _ts_decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/experimental/assistant/src/cypher/echo-data-source.ts";
-var EchoDataSource = class {
-  constructor(_db) {
-    this._db = _db;
-  }
-  async getNodes({ label: label2 }) {
-    if (!label2) {
-      const { objects: objects2 } = await this._db.query().run();
-      return objects2.map(this._objectToNode);
-    }
-    const schema = (await this._getAllSchema()).find((s) => (0, import_echo_schema2.getSchemaTypename)(s)?.endsWith(label2));
-    if (!schema) {
-      return [];
-    }
-    const { objects } = await this._db.query(import_echo_db.Filter.schema(schema)).run();
-    return objects.map(this._objectToNode);
-  }
-  async getRelationships({ label: label2 }) {
-    const syntheticRefRelationships = (await this._getAllSchema()).filter((schema) => (0, import_echo_schema2.getSchemaTypename)(schema) !== import_echo_schema2.StoredSchema.typename).flatMap((schema) => {
-      const jsonSchema = (0, import_echo_schema2.toJsonSchema)(schema);
-      const relationships = Object.entries(jsonSchema.properties).filter(([key, prop]) => isReference(prop));
-      return relationships.map(([key, value]) => {
-        const relationshipLabel = formatInferredRelationshipLabel(jsonSchema.typename ?? (0, import_debug2.raise)(new Error("Schema must have typename")), key);
-        return {
-          label: relationshipLabel,
-          schema,
-          property: key
-        };
-      });
-    });
-    const relationship = syntheticRefRelationships.find((r) => r.label === label2);
-    if (!relationship) {
-      return [];
-    }
-    const { objects } = await this._db.query(import_echo_db.Filter.schema(relationship.schema)).run();
-    return (await Promise.all(objects.map((object) => this._projectRefRelationship(object, relationship.property)))).flat();
-  }
-  async _getAllSchema() {
-    return [
-      ...await this._db.schemaRegistry.query().run(),
-      // TODO(dmaretskyi): Remove once we can serialize recursive schema.
-      ...this._db.graph.schemaRegistry.schemas.filter((s) => (0, import_echo_schema2.getSchemaTypename)(s)?.startsWith("example.org"))
-    ].filter((schema) => (0, import_echo_schema2.getSchemaTypename)(schema) !== import_echo_schema2.StoredSchema.typename);
-  }
-  _objectToNode(object) {
-    const { id, ...properties2 } = object;
-    return {
-      id,
-      kind: "node",
-      label: formatNodeLabel((0, import_echo_schema2.getSchemaTypename)((0, import_live_object.getSchema)(object))),
-      properties: properties2
-    };
-  }
-  async _projectRefRelationship(object, prop) {
-    if (!object[prop]) {
-      return [];
-    }
-    const value = Array.isArray(object[prop]) ? object[prop] : [
-      object[prop]
-    ];
-    return Promise.all(value.map(async (ref) => {
-      const target = await ref.load();
-      return {
-        id: `${object.id}-${prop}-${target.id}`,
-        kind: "relationship",
-        label: formatInferredRelationshipLabel((0, import_echo_schema2.getSchemaTypename)((0, import_live_object.getSchema)(object)), prop),
-        properties: {},
-        source: this._objectToNode(object),
-        target: this._objectToNode(target)
-      };
-    }));
-  }
-};
-_ts_decorate([
-  import_log3.log.method(void 0, void 0, {
-    F: __dxlog_file3,
-    L: 17,
-    S: void 0,
-    C: (f, a) => f(...a)
-  })
-], EchoDataSource.prototype, "getNodes", null);
-_ts_decorate([
-  import_log3.log.method(void 0, void 0, {
-    F: __dxlog_file3,
-    L: 34,
-    S: void 0,
-    C: (f, a) => f(...a)
-  })
-], EchoDataSource.prototype, "getRelationships", null);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  EchoDataSource,
-  executeQuery,
-  executeQueryPlan,
-  formatInferredRelationshipLabel,
-  formatJsonSchemaForLLM,
-  formatNodeLabel,
-  isReference,
-  parseCypherQuery,
-  trim
-});
-//# sourceMappingURL=chunk-QPHGQINW.cjs.map