open-agents-ai 0.187.432 → 0.187.433

package/dist/index.js

@@ -514275,9 +514275,634 @@ var init_embeddingAligner = __esm({
   }
 });
 
+// packages/memory/dist/crl/index.js
+var CRL_SYMBOLS, SYMBOL_MEANINGS, CRLParser, CRLEncoder, CRLDecoder, CRLTemplateResolver, CRL;
+var init_crl = __esm({
+  "packages/memory/dist/crl/index.js"() {
+    "use strict";
+    CRL_SYMBOLS = {
+      // Logical operators
+      THEREFORE: "∴",
+      BECAUSE: "∵",
+      EQUIVALENT: "≡",
+      IMPLIES: "→",
+      BICONDITIONAL: "↔",
+      NOT: "¬",
+      AND: "∧",
+      OR: "∨",
+      XOR: "⊕",
+      // Relational operators
+      ELEMENT_OF: "∈",
+      NOT_ELEMENT_OF: "∉",
+      PROPER_SUBSET: "⊂",
+      SUBSET_OR_EQUAL: "⊆",
+      UNION: "∪",
+      INTERSECTION: "∩",
+      EMPTY: "∅",
+      // Temporal/Sequential
+      THEN: "⇒",
+      FROM: "⇐",
+      LOOP: "⟳",
+      CYCLE: "↻",
+      NEXT: "⏵",
+      PREVIOUS: "⏴",
+      // Modal/Evidential
+      POSSIBLE: "◇",
+      NECESSARY: "□",
+      OBSERVED: "⊙",
+      UNCERTAIN: "?",
+      CRITICAL: "!",
+      APPROXIMATE: "~",
+      // Quantifiers
+      FOR_ALL: "∀",
+      EXISTS: "∃",
+      NOT_EXISTS: "∄",
+      AGGREGATE: "∑",
+      PRODUCT: "∏"
+    };
+    SYMBOL_MEANINGS = {
+      "∴": "therefore",
+      "∵": "because",
+      "≡": "equivalent",
+      "→": "implies",
+      "↔": "biconditional",
+      "¬": "not",
+      "∧": "and",
+      "∨": "or",
+      "⊕": "xor",
+      "∈": "element_of",
+      "∉": "not_element_of",
+      "⊂": "proper_subset",
+      "⊆": "subset_or_equal",
+      "∪": "union",
+      "∩": "intersection",
+      "∅": "empty",
+      "⇒": "then",
+      "⇐": "from",
+      "⟳": "loop",
+      "↻": "cycle",
+      "⏵": "next",
+      "⏴": "previous",
+      "◇": "possible",
+      "□": "necessary",
+      "⊙": "observed",
+      "?": "uncertain",
+      "!": "critical",
+      "~": "approximate",
+      "∀": "for_all",
+      "∃": "exists",
+      "∄": "not_exists",
+      "∑": "aggregate",
+      "∏": "product"
+    };
+    CRLParser = class {
+      pos = 0;
+      input = "";
+      parse(input) {
+        this.input = input;
+        this.pos = 0;
+        const nodes = [];
+        const start2 = this.pos;
+        while (this.pos < this.input.length) {
+          this.skipWhitespace();
+          if (this.pos >= this.input.length)
+            break;
+          const node = this.parseNode();
+          if (node)
+            nodes.push(node);
+        }
+        return {
+          type: "statement",
+          nodes,
+          raw: input,
+          position: { start: start2, end: this.pos }
+        };
+      }
+      parseNode() {
+        this.skipWhitespace();
+        if (this.peek() === "[") {
+          return this.parseConcept();
+        }
+        if (this.peek() === "$" && this.peek(1) === "{") {
+          return this.parseTemplate();
+        }
+        if (this.isQuantifier(this.peek())) {
+          return this.parseQuantifier();
+        }
+        if (this.isOperator(this.peek())) {
+          return this.parseOperator();
+        }
+        this.pos++;
+        return null;
+      }
+      parseConcept() {
+        const start2 = this.pos;
+        this.pos++;
+        let name10 = "";
+        while (this.pos < this.input.length && this.peek() !== "]") {
+          name10 += this.peek();
+          this.pos++;
+        }
+        this.pos++;
+        let properties;
+        if (this.peek() === "{") {
+          properties = this.parseProperties();
+        }
+        let strength;
+        if (this.peek() === "★") {
+          strength = 0;
+          while (this.peek() === "★") {
+            strength++;
+            this.pos++;
+          }
+        }
+        return {
+          type: "concept",
+          name: name10.trim(),
+          properties,
+          strength,
+          raw: this.input.substring(start2, this.pos),
+          position: { start: start2, end: this.pos }
+        };
+      }
+      parseProperties() {
+        const props = {};
+        this.pos++;
+        while (this.pos < this.input.length && this.peek() !== "}") {
+          const key = this.parseIdentifier();
+          if (this.peek() === ":") {
+            this.pos++;
+            const value2 = this.parseIdentifier();
+            props[key] = value2;
+          }
+          if (this.peek() === ",")
+            this.pos++;
+        }
+        this.pos++;
+        return props;
+      }
+      parseIdentifier() {
+        let id = "";
+        while (this.pos < this.input.length && /[a-zA-Z0-9_]/.test(this.peek())) {
+          id += this.peek();
+          this.pos++;
+        }
+        return id;
+      }
+      parseTemplate() {
+        const start2 = this.pos;
+        this.pos += 2;
+        let variable = "";
+        let defaultValue;
+        let typeAnnotation;
+        let transform;
+        while (this.pos < this.input.length && this.peek() !== "}" && this.peek() !== ":" && this.peek() !== "|" && this.peek() !== "→") {
+          variable += this.peek();
+          this.pos++;
+        }
+        if (this.peek() === ":") {
+          this.pos++;
+          defaultValue = "";
+          while (this.pos < this.input.length && this.peek() !== "}") {
+            defaultValue += this.peek();
+            this.pos++;
+          }
+        }
+        if (this.peek() === "|") {
+          this.pos++;
+          typeAnnotation = "";
+          while (this.pos < this.input.length && this.peek() !== "}" && this.peek() !== "→") {
+            typeAnnotation += this.peek();
+            this.pos++;
+          }
+        }
+        if (this.peek() === "→") {
+          this.pos++;
+          transform = "";
+          while (this.pos < this.input.length && this.peek() !== "}") {
+            transform += this.peek();
+            this.pos++;
+          }
+        }
+        this.pos++;
+        return {
+          type: "template",
+          variable: variable.trim(),
+          defaultValue,
+          typeAnnotation,
+          transform,
+          raw: this.input.substring(start2, this.pos),
+          position: { start: start2, end: this.pos }
+        };
+      }
+      parseQuantifier() {
+        const start2 = this.pos;
+        const quantifier = this.peek();
+        this.pos++;
+        let variable = "";
+        while (this.pos < this.input.length && /[a-zA-Z_]/.test(this.peek())) {
+          variable += this.peek();
+          this.pos++;
+        }
+        let domain;
+        if (this.peek() === "∈") {
+          this.pos++;
+          this.skipWhitespace();
+          domain = this.parseConcept();
+        }
+        this.skipWhitespace();
+        if (this.peek() === ":")
+          this.pos++;
+        this.skipWhitespace();
+        const predicate = this.parseNode();
+        return {
+          type: "quantifier",
+          quantifier,
+          variable,
+          domain,
+          predicate,
+          raw: this.input.substring(start2, this.pos),
+          position: { start: start2, end: this.pos }
+        };
+      }
+      parseOperator() {
+        const start2 = this.pos;
+        const op = this.peek();
+        this.pos++;
+        return {
+          type: "relation",
+          raw: op,
+          position: { start: start2, end: this.pos }
+        };
+      }
+      skipWhitespace() {
+        while (this.pos < this.input.length && /\s/.test(this.peek())) {
+          this.pos++;
+        }
+      }
+      peek(offset = 0) {
+        return this.input[this.pos + offset] || "";
+      }
+      isQuantifier(char) {
+        return ["∀", "∃", "∄", "∑", "∏"].includes(char);
+      }
+      isOperator(char) {
+        return [
+          "∴",
+          "∵",
+          "≡",
+          "→",
+          "↔",
+          "¬",
+          "∧",
+          "∨",
+          "⊕",
+          "∈",
+          "∉",
+          "⊂",
+          "⊆",
+          "∪",
+          "∩",
+          "⇒",
+          "⇐"
+        ].includes(char);
+      }
+    };
+    CRLEncoder = class {
+      conceptPatterns = /* @__PURE__ */ new Map();
+      /**
+       * Encode natural language text to CRL
+       */
+      encode(text) {
+        const concepts = this.extractConcepts(text);
+        const relations = this.extractRelations(text, concepts);
+        return this.buildExpression(concepts, relations);
+      }
+      /**
+       * Extract key concepts from text
+       */
+      extractConcepts(text) {
+        const concepts = [];
+        const conceptPattern = /\[([^\]]+)\]/g;
+        let match;
+        while ((match = conceptPattern.exec(text)) !== null) {
+          concepts.push({
+            type: "concept",
+            name: match[1],
+            raw: match[0],
+            position: { start: match.index, end: match.index + match[0].length }
+          });
+        }
+        const implicitPattern = /\b([A-Z][a-z]+(?:_[A-Z][a-z]+)*)\b/g;
+        while ((match = implicitPattern.exec(text)) !== null) {
+          if (!concepts.find((c9) => c9.name === match[1])) {
+            concepts.push({
+              type: "concept",
+              name: match[1],
+              raw: match[0],
+              position: { start: match.index, end: match.index + match[0].length }
+            });
+          }
+        }
+        return concepts;
+      }
+      /**
+       * Extract relations between concepts
+       */
+      extractRelations(text, concepts) {
+        const relations = [];
+        const relationPattern = /\[([^\]]+)\]\s*(→|↔|∴|∵|⇒|⇐)(?::(\w+))?\s*(?:→)?\s*\[([^\]]+)\]/g;
+        let match;
+        while ((match = relationPattern.exec(text)) !== null) {
+          const from3 = concepts.find((c9) => c9.name === match[1]);
+          const to = concepts.find((c9) => c9.name === match[4]);
+          if (from3 && to) {
+            relations.push({
+              type: "relation",
+              from: from3,
+              to,
+              operator: match[2],
+              edgeType: match[3],
+              raw: match[0],
+              position: { start: match.index, end: match.index + match[0].length }
+            });
+          }
+        }
+        return relations;
+      }
+      /**
+       * Build CRL expression from concepts and relations
+       */
+      buildExpression(concepts, relations) {
+        const lines = [];
+        for (const rel of relations) {
+          let line = `[${rel.from.name}] ${rel.operator}`;
+          if (rel.edgeType)
+            line += `:${rel.edgeType}`;
+          line += ` [${rel.to.name}]`;
+          lines.push(line);
+        }
+        const relatedConcepts = /* @__PURE__ */ new Set();
+        for (const rel of relations) {
+          relatedConcepts.add(rel.from.name);
+          relatedConcepts.add(rel.to.name);
+        }
+        for (const concept of concepts) {
+          if (!relatedConcepts.has(concept.name)) {
+            lines.push(`[${concept.name}]`);
+          }
+        }
+        return lines.join("\n");
+      }
+      /**
+       * Compress text using CRL patterns
+       */
+      compress(text) {
+        const replacements = [
+          [/therefore/gi, "∴"],
+          [/because/gi, "∵"],
+          [/implies that/gi, "→"],
+          [/is equivalent to/gi, "≡"],
+          [/is an? element of/gi, "∈"],
+          [/is not an? element of/gi, "∉"],
+          [/is a subset of/gi, "⊂"],
+          [/for all/gi, "∀"],
+          [/there exists/gi, "∃"],
+          [/and then/gi, "⇒"],
+          [/leads to/gi, "→"],
+          [/causes/gi, "→:causes"],
+          [/fixes/gi, "→:fixes"],
+          [/relates to/gi, "∩"]
+        ];
+        let result = text;
+        for (const [pattern, replacement] of replacements) {
+          result = result.replace(pattern, replacement);
+        }
+        return result;
+      }
+    };
+    CRLDecoder = class {
+      /**
+       * Decode CRL expression to natural language
+       */
+      decode(crl) {
+        const parser2 = new CRLParser();
+        const ast = parser2.parse(crl);
+        return this.renderStatement(ast);
+      }
+      /**
+       * Render a statement node
+       */
+      renderStatement(node) {
+        return node.nodes.map((n2) => this.renderNode(n2)).filter(Boolean).join(". ");
+      }
+      /**
+       * Render any CRL node
+       */
+      renderNode(node) {
+        switch (node.type) {
+          case "concept":
+            return this.renderConcept(node);
+          case "template":
+            return this.renderTemplate(node);
+          case "quantifier":
+            return this.renderQuantifier(node);
+          case "relation":
+            return this.renderRelation(node);
+          default:
+            return "";
+        }
+      }
+      /**
+       * Render a concept
+       */
+      renderConcept(node) {
+        let result = node.name;
+        if (node.properties) {
+          const props = Object.entries(node.properties).map(([k, v]) => `${k}=${v}`).join(", ");
+          result += ` (${props})`;
+        }
+        if (node.strength) {
+          result += ` [strength: ${node.strength}/5]`;
+        }
+        return result;
+      }
+      /**
+       * Render a template
+       */
+      renderTemplate(node) {
+        let result = node.variable;
+        if (node.typeAnnotation) {
+          result += ` (${node.typeAnnotation})`;
+        }
+        if (node.defaultValue) {
+          result += ` [default: ${node.defaultValue}]`;
+        }
+        return result;
+      }
+      /**
+       * Render a quantifier
+       */
+      renderQuantifier(node) {
+        const quantifierMeanings = {
+          "∀": "For all",
+          "∃": "There exists",
+          "∄": "There does not exist",
+          "∑": "Sum of",
+          "∏": "Product of"
+        };
+        let result = `${quantifierMeanings[node.quantifier]} ${node.variable}`;
+        if (node.domain) {
+          result += ` in ${this.renderNode(node.domain)}`;
+        }
+        if (node.predicate) {
+          result += `, ${this.renderNode(node.predicate)}`;
+        }
+        return result;
+      }
+      /**
+       * Render a relation
+       */
+      renderRelation(node) {
+        const operatorMeanings = {
+          "→": "implies",
+          "∴": "therefore",
+          "∵": "because",
+          "≡": "is equivalent to",
+          "↔": "is mutually related to",
+          "∈": "is an element of",
+          "⊂": "is a subset of",
+          "∪": "combined with",
+          "∩": "intersects with",
+          "⇒": "then",
+          "⇐": "from"
+        };
+        const from3 = this.renderConcept(node.from);
+        const to = this.renderConcept(node.to);
+        const op = operatorMeanings[node.operator] || node.operator;
+        if (node.edgeType) {
+          return `${from3} ${node.edgeType} ${to}`;
+        }
+        return `${from3} ${op} ${to}`;
+      }
+      /**
+       * Expand CRL symbols to natural language
+       */
+      expand(text) {
+        const expansions = {
+          "∴": "therefore",
+          "∵": "because",
+          "≡": "is equivalent to",
+          "→": "implies",
+          "↔": "is mutually related to",
+          "¬": "not",
+          "∧": "and",
+          "∨": "or",
+          "∈": "is an element of",
+          "∉": "is not an element of",
+          "⊂": "is a subset of",
+          "⊆": "is a subset of or equal to",
+          "∪": "union with",
+          "∩": "intersection with",
+          "∅": "empty",
+          "⇒": "then",
+          "⇐": "from",
+          "◇": "possibly",
+          "□": "necessarily",
+          "⊙": "observed",
+          "∀": "for all",
+          "∃": "there exists",
+          "∄": "there does not exist"
+        };
+        let result = text;
+        for (const [symbol3, expansion] of Object.entries(expansions)) {
+          result = result.replace(new RegExp(symbol3, "g"), ` ${expansion} `);
+        }
+        return result.replace(/\s+/g, " ").trim();
+      }
+    };
+    CRLTemplateResolver = class {
+      /**
+       * Resolve templates in CRL expression
+       */
+      resolve(crl, context2) {
+        const templatePattern = /\$\{([^}]+)\}/g;
+        return crl.replace(templatePattern, (match, template) => {
+          return this.resolveTemplate(template, context2);
+        });
+      }
+      resolveTemplate(template, context2) {
+        const parts = template.split(/[:|→]/);
+        const variable = parts[0].trim();
+        const defaultValue = parts[1]?.trim();
+        const typeAnnotation = parts[2]?.trim();
+        let value2;
+        if (variable.startsWith("ctx:")) {
+          const ctxVar = variable.substring(5);
+          value2 = context2[ctxVar];
+        } else if (variable.startsWith("mem:")) {
+          const memVar = variable.substring(4);
+          const memArray = context2.memories?.[memVar];
+          value2 = memArray?.join(", ");
+        } else if (variable.startsWith("state:")) {
+          const stateVar = variable.substring(6);
+          value2 = context2.state?.[stateVar];
+        } else {
+          value2 = context2.variables?.[variable];
+        }
+        return value2 || defaultValue || `[${variable}]`;
+      }
+    };
+    CRL = {
+      parser: new CRLParser(),
+      encoder: new CRLEncoder(),
+      decoder: new CRLDecoder(),
+      resolver: new CRLTemplateResolver(),
+      symbols: CRL_SYMBOLS,
+      meanings: SYMBOL_MEANINGS,
+      /**
+       * Quick encode: natural language → CRL
+       */
+      encode(text) {
+        return this.encoder.encode(text);
+      },
+      /**
+       * Quick decode: CRL → natural language
+       */
+      decode(crl) {
+        return this.decoder.decode(crl);
+      },
+      /**
+       * Quick compress: replace common patterns with symbols
+       */
+      compress(text) {
+        return this.encoder.compress(text);
+      },
+      /**
+       * Quick expand: replace symbols with natural language
+       */
+      expand(text) {
+        return this.decoder.expand(text);
+      },
+      /**
+       * Resolve templates with context
+       */
+      resolve(crl, context2) {
+        return this.resolver.resolve(crl, context2);
+      }
+    };
+  }
+});
+
 // packages/memory/dist/index.js
 var dist_exports2 = {};
 __export(dist_exports2, {
+  CRL: () => CRL,
+  CRLDecoder: () => CRLDecoder,
+  CRLEncoder: () => CRLEncoder,
+  CRLParser: () => CRLParser,
+  CRLTemplateResolver: () => CRLTemplateResolver,
+  CRL_SYMBOLS: () => CRL_SYMBOLS,
   DECAY_TAU: () => DECAY_TAU,
   EmbeddingAligner: () => EmbeddingAligner,
   EpisodeStore: () => EpisodeStore,
@@ -514286,6 +514911,7 @@ __export(dist_exports2, {
   PatchHistoryStore: () => PatchHistoryStore,
   ProceduralMemoryStore: () => ProceduralMemoryStore,
   RepoProfileStore: () => RepoProfileStore,
+  SYMBOL_MEANINGS: () => SYMBOL_MEANINGS,
   TaskMemoryStore: () => TaskMemoryStore,
   TemporalGraph: () => TemporalGraph,
   ToolPatternStore: () => ToolPatternStore,
@@ -514333,6 +514959,7 @@ var init_dist7 = __esm({
     init_proceduralMemoryStore();
     init_splanifold();
     init_embeddingAligner();
+    init_crl();
   }
 });
 

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.432",
+  "version": "0.187.433",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "open-agents-ai",
-      "version": "0.187.432",
+      "version": "0.187.433",
       "hasInstallScript": true,
       "license": "CC-BY-NC-4.0",
       "dependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.432",
+  "version": "0.187.433",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",