@o-lang/olang 1.0.3 → 1.0.5

package/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 const { Command } = require('commander');
-const { parse } = require('./src/parser');
-const { execute } = require('./src/runtime');
+const { parse } = require('../src/parser'); // adjusted path if bin vs root
+const { execute } = require('../src/runtime');
 const fs = require('fs');
 const path = require('path');
 
@@ -21,6 +21,8 @@ function ensureOlExtension(filename) {
  * Default mock resolver (for demo use)
  */
 async function defaultMockResolver(action, context) {
+  if (!action || typeof action !== 'string') return `[Unhandled: ${String(action)}]`;
+
   if (action.startsWith('Search for ')) {
     return {
       title: "HR Policy 2025",
@@ -46,6 +48,44 @@ async function defaultMockResolver(action, context) {
   return `[Unhandled: ${action}]`;
 }
 
+/**
+ * Built-in Math Resolver (so action style math strings are handled too)
+ * Supports action strings like: add(1,2), subtract(5,2), multiply(2,3), divide(6,3), sum([1,2,3])
+ * Note: runtime handles calculate steps; this resolver helps when parser emits actions with math strings.
+ */
+async function builtInMathResolver(action, context) {
+  if (!action || typeof action !== 'string') return null;
+
+  // Replace contextual placeholders {var}
+  const a = action.replace(/\{([^\}]+)\}/g, (_, k) => {
+    const v = context[k.trim()];
+    return v !== undefined ? v : `{${k}}`;
+  });
+
+  // simple function matches
+  let m;
+  m = a.match(/^add\(([^,]+),\s*([^)]+)\)$/i);
+  if (m) return parseFloat(m[1]) + parseFloat(m[2]);
+
+  m = a.match(/^subtract\(([^,]+),\s*([^)]+)\)$/i);
+  if (m) return parseFloat(m[1]) - parseFloat(m[2]);
+
+  m = a.match(/^multiply\(([^,]+),\s*([^)]+)\)$/i);
+  if (m) return parseFloat(m[1]) * parseFloat(m[2]);
+
+  m = a.match(/^divide\(([^,]+),\s*([^)]+)\)$/i);
+  if (m) return parseFloat(m[1]) / parseFloat(m[2]);
+
+  m = a.match(/^sum\(\s*\[([^\]]+)\]\s*\)$/i);
+  if (m) {
+    const arr = m[1].split(',').map(s => parseFloat(s.trim()));
+    return arr.reduce((s, v) => s + v, 0);
+  }
+
+  // not a math action
+  return null;
+}
+
 /**
  * Resolver chaining mechanism
  */
@@ -90,13 +130,19 @@ function loadSingleResolver(specifier) {
   }
 }
 
+/**
+ * loadResolverChain: include built-in math resolver first, then user resolvers, then default mock resolver
+ */
 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 +166,9 @@ program
     'Input parameters',
     (val, acc = {}) => {
       const [k, v] = val.split('=');
-      acc[k] = v;
+      // try to parse numbers, preserve strings otherwise
+      const parsed = v === undefined ? '' : (v === 'true' ? true : (v === 'false' ? false : (isNaN(v) ? v : parseFloat(v))));
+      acc[k] = parsed;
       return acc;
     },
     {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@o-lang/olang",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "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/parser.js

@@ -22,6 +22,62 @@ function parse(code, fileName = null) {
   while (i < lines.length) {
     let line = lines[i];
 
+    // ============================
+    // NEW: Detect math operations
+    // ============================
+
+    // Add X and Y
+    let mathAdd = line.match(/^Add\s+\{(.+?)\}\s+and\s+\{(.+?)\}\s+Save as\s+(.+)$/i);
+    if (mathAdd) {
+      workflow.steps.push({
+        type: 'calculate',
+        expression: `add({${mathAdd[1]}}, {${mathAdd[2]}})`,
+        saveAs: mathAdd[3].trim()
+      });
+      i++;
+      continue;
+    }
+
+    // Subtract A from B => B - A
+    let mathSub = line.match(/^Subtract\s+\{(.+?)\}\s+from\s+\{(.+?)\}\s+Save as\s+(.+)$/i);
+    if (mathSub) {
+      workflow.steps.push({
+        type: 'calculate',
+        expression: `subtract({${mathSub[2]}}, {${mathSub[1]}})`,
+        saveAs: mathSub[3].trim()
+      });
+      i++;
+      continue;
+    }
+
+    // Multiply X and Y
+    let mathMul = line.match(/^Multiply\s+\{(.+?)\}\s+and\s+\{(.+?)\}\s+Save as\s+(.+)$/i);
+    if (mathMul) {
+      workflow.steps.push({
+        type: 'calculate',
+        expression: `multiply({${mathMul[1]}}, {${mathMul[2]}})`,
+        saveAs: mathMul[3].trim()
+      });
+      i++;
+      continue;
+    }
+
+    // Divide A by B
+    let mathDiv = line.match(/^Divide\s+\{(.+?)\}\s+by\s+\{(.+?)\}\s+Save as\s+(.+)$/i);
+    if (mathDiv) {
+      workflow.steps.push({
+        type: 'calculate',
+        expression: `divide({${mathDiv[1]}}, {${mathDiv[2]}})`,
+        saveAs: mathDiv[3].trim()
+      });
+      i++;
+      continue;
+    }
+
+    // ====================== END NEW MATH RULES ======================
+
+
+
     // Workflow
     const wfMatch = line.match(/^Workflow\s+"([^"]+)"(?:\s+with\s+(.+))?/i);
     if (wfMatch) {

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,27 +47,111 @@ 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());
+      // if value is string, wrap in quotes for functions that accept strings
+      if (typeof value === 'string') return `"${value.replace(/"/g, '\\"')}"`;
+      return value !== undefined ? value : 0;
+    });
+
+    // expose safe 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': {
+        // step.expression or actionRaw can contain math expression strings
+        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());
           return value !== undefined ? String(value) : `{${path}}`;
         });
+
+        // Provide fallback math recognition for action lines too (e.g., add(1,2))
+        // Try simple math function calls in action form
+        const mathCall = action.match(/^(add|subtract|multiply|divide|sum|avg|min|max|round|floor|ceil|abs)\((.*)\)$/i);
+        if (mathCall) {
+          const fn = mathCall[1].toLowerCase();
+          const argsRaw = mathCall[2];
+          // simple split by comma (doesn't handle nested arrays/funcs) — fine for workflow math
+          const args = argsRaw.split(',').map(s => s.trim()).map(s => {
+            // if it's a quoted string
+            if (/^".*"$/.test(s) || /^'.*'$/.test(s)) return s.slice(1, -1);
+            // try number
+            if (!isNaN(s)) return parseFloat(s);
+            // variable lookup
+            const lookup = s.replace(/^\{|\}$/g, '').trim();
+            return this.getNested(this.context, lookup);
+          });
+
+          if (this.mathFunctions[fn]) {
+            const value = this.mathFunctions[fn](...args);
+            if (step.saveAs) this.context[step.saveAs] = value;
+            break;
+          }
+        }
+
+        // fallback to agent resolver
         const res = await agentResolver(action, this.context);
         if (step.saveAs) this.context[step.saveAs] = res;
         break;
       }
 
       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;