@o-lang/olang 1.0.3 → 1.0.4

package/cli.js

@@ -46,6 +46,34 @@ async function defaultMockResolver(action, context) {
   return `[Unhandled: ${action}]`;
 }
 
+/**
+ * Built-in Math Resolver
+ * Supports minimal math operations for workflows
+ */
+async function builtInMathResolver(action, context) {
+  // Replace variables in context
+  action = action.replace(/\{([^\}]+)\}/g, (_, key) => {
+    const val = context[key.trim()];
+    return val !== undefined ? val : `{${key}}`;
+  });
+
+  let match;
+
+  match = action.match(/^add\(([^,]+),\s*([^)]+)\)$/);
+  if (match) return parseFloat(match[1]) + parseFloat(match[2]);
+
+  match = action.match(/^subtract\(([^,]+),\s*([^)]+)\)$/);
+  if (match) return parseFloat(match[1]) - parseFloat(match[2]);
+
+  match = action.match(/^multiply\(([^,]+),\s*([^)]+)\)$/);
+  if (match) return parseFloat(match[1]) * parseFloat(match[2]);
+
+  match = action.match(/^divide\(([^,]+),\s*([^)]+)\)$/);
+  if (match) return parseFloat(match[1]) / parseFloat(match[2]);
+
+  return null; // not handled
+}
+
 /**
  * Resolver chaining mechanism
  */
@@ -90,13 +118,20 @@ function loadSingleResolver(specifier) {
   }
 }
 
+/**
+ * Updated resolver chain
+ * Built-in math resolver is added first, then user resolvers, then default mock
+ */
 function loadResolverChain(specifiers) {
+  const userResolvers = specifiers?.map(loadSingleResolver) || [];
+  const resolvers = [builtInMathResolver, ...userResolvers, defaultMockResolver];
+
   if (!specifiers || specifiers.length === 0) {
-    console.log('ℹ️ No resolver provided. Using default mock resolver.');
-    return defaultMockResolver;
+    console.log('ℹ️ No resolver provided. Using built-in math + default mock resolver.');
+  } else {
+    console.log(`📦 Loaded user resolvers: ${specifiers.join(', ')}`);
   }
 
-  const resolvers = specifiers.map(loadSingleResolver);
   return createResolverChain(resolvers);
 }
 
@@ -120,7 +155,7 @@ program
     'Input parameters',
     (val, acc = {}) => {
       const [k, v] = val.split('=');
-      acc[k] = v;
+      acc[k] = isNaN(v) ? v : parseFloat(v);
       return acc;
     },
     {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@o-lang/olang",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "author": "Olalekan Ogundipe <info@workfily.com>",
   "description": "O-Lang: A governance language for user-directed, rule-enforced agent workflows",
   "main": "./src/index.js",

package/src/runtime.js

@@ -24,9 +24,11 @@ class RuntimeAPI {
   evaluateCondition(cond, ctx) {
     cond = cond.trim();
     const eq = cond.match(/^\{(.+)\}\s+equals\s+"(.*)"$/);
-    if (eq) return this.getNested(ctx, eq[1]) === eq[2];
+    if (eq) return this.getNested(ctx, eq[1]) == eq[2];
     const gt = cond.match(/^\{(.+)\}\s+greater than\s+(\d+\.?\d*)$/);
     if (gt) return parseFloat(this.getNested(ctx, gt[1])) > parseFloat(gt[2]);
+    const lt = cond.match(/^\{(.+)\}\s+less than\s+(\d+\.?\d*)$/);
+    if (lt) return parseFloat(this.getNested(ctx, lt[1])) < parseFloat(lt[2]);
     return Boolean(this.getNested(ctx, cond.replace(/\{|\}/g, '')));
   }
 
@@ -45,8 +47,66 @@ class RuntimeAPI {
     return null;
   }
 
+  // --------------------------
+  // Math helper functions
+  // --------------------------
+  mathFunctions = {
+    add: (a, b) => a + b,
+    subtract: (a, b) => a - b,
+    multiply: (a, b) => a * b,
+    divide: (a, b) => a / b,
+    equals: (a, b) => a === b,
+    greater: (a, b) => a > b,
+    less: (a, b) => a < b,
+    sum: arr => arr.reduce((acc, val) => acc + val, 0),
+    avg: arr => arr.reduce((acc, val) => acc + val, 0) / arr.length,
+    min: arr => Math.min(...arr),
+    max: arr => Math.max(...arr),
+    increment: a => a + 1,
+    decrement: a => a - 1,
+    round: a => Math.round(a),
+    floor: a => Math.floor(a),
+    ceil: a => Math.ceil(a),
+    abs: a => Math.abs(a)
+  };
+
+  evaluateMath(expr) {
+    // Replace context variables in curly braces
+    expr = expr.replace(/\{([^\}]+)\}/g, (_, path) => {
+      const value = this.getNested(this.context, path.trim());
+      return value !== undefined ? value : 0;
+    });
+
+    // Create a function for supported math functions only
+    const funcNames = Object.keys(this.mathFunctions);
+    const safeFunc = {};
+    funcNames.forEach(fn => {
+      safeFunc[fn] = this.mathFunctions[fn];
+    });
+
+    try {
+      // eslint-disable-next-line no-new-func
+      const f = new Function(...funcNames, `return ${expr};`);
+      return f(...funcNames.map(fn => safeFunc[fn]));
+    } catch (e) {
+      console.warn(`[O-Lang] Failed to evaluate math expression "${expr}": ${e.message}`);
+      return 0;
+    }
+  }
+
+  // --------------------------
+  // Execute workflow step
+  // --------------------------
   async executeStep(step, agentResolver) {
     switch (step.type) {
+      case 'calculate': {
+        // e.g., "add({x}, {y})"
+        const expr = step.expression || step.actionRaw;
+        const result = this.evaluateMath(expr);
+        if (step.saveAs) this.context[step.saveAs] = result;
+        break;
+      }
+
       case 'action': {
         const action = step.actionRaw.replace(/\{([^\}]+)\}/g, (_, path) => {
           const value = this.getNested(this.context, path.trim());
@@ -58,14 +118,12 @@ class RuntimeAPI {
       }
 
       case 'use': {
-        // "Use <Tool>" step
         const res = await agentResolver(`Use ${step.tool}`, this.context);
         if (step.saveAs) this.context[step.saveAs] = res;
         break;
       }
 
       case 'ask': {
-        // "Ask <Target>" step
         const res = await agentResolver(`Ask ${step.target}`, this.context);
         if (step.saveAs) this.context[step.saveAs] = res;
         break;