@o-lang/olang 1.0.4 → 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",
@@ -47,31 +49,41 @@ async function defaultMockResolver(action, context) {
 }
 
 /**
- * Built-in Math Resolver
- * Supports minimal math operations for workflows
+ * 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) {
-  // Replace variables in context
-  action = action.replace(/\{([^\}]+)\}/g, (_, key) => {
-    const val = context[key.trim()];
-    return val !== undefined ? val : `{${key}}`;
+  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}}`;
   });
 
-  let match;
+  // simple function matches
+  let m;
+  m = a.match(/^add\(([^,]+),\s*([^)]+)\)$/i);
+  if (m) return parseFloat(m[1]) + parseFloat(m[2]);
 
-  match = action.match(/^add\(([^,]+),\s*([^)]+)\)$/);
-  if (match) return parseFloat(match[1]) + parseFloat(match[2]);
+  m = a.match(/^subtract\(([^,]+),\s*([^)]+)\)$/i);
+  if (m) return parseFloat(m[1]) - parseFloat(m[2]);
 
-  match = action.match(/^subtract\(([^,]+),\s*([^)]+)\)$/);
-  if (match) return parseFloat(match[1]) - parseFloat(match[2]);
+  m = a.match(/^multiply\(([^,]+),\s*([^)]+)\)$/i);
+  if (m) return parseFloat(m[1]) * parseFloat(m[2]);
 
-  match = action.match(/^multiply\(([^,]+),\s*([^)]+)\)$/);
-  if (match) return parseFloat(match[1]) * parseFloat(match[2]);
+  m = a.match(/^divide\(([^,]+),\s*([^)]+)\)$/i);
+  if (m) return parseFloat(m[1]) / parseFloat(m[2]);
 
-  match = action.match(/^divide\(([^,]+),\s*([^)]+)\)$/);
-  if (match) return parseFloat(match[1]) / parseFloat(match[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);
+  }
 
-  return null; // not handled
+  // not a math action
+  return null;
 }
 
 /**
@@ -119,8 +131,7 @@ function loadSingleResolver(specifier) {
 }
 
 /**
- * Updated resolver chain
- * Built-in math resolver is added first, then user resolvers, then default mock
+ * loadResolverChain: include built-in math resolver first, then user resolvers, then default mock resolver
  */
 function loadResolverChain(specifiers) {
   const userResolvers = specifiers?.map(loadSingleResolver) || [];
@@ -155,7 +166,9 @@ program
     'Input parameters',
     (val, acc = {}) => {
       const [k, v] = val.split('=');
-      acc[k] = isNaN(v) ? v : parseFloat(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.4",
+  "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

@@ -74,10 +74,12 @@ class RuntimeAPI {
     // 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;
     });
 
-    // Create a function for supported math functions only
+    // expose safe functions only
     const funcNames = Object.keys(this.mathFunctions);
     const safeFunc = {};
     funcNames.forEach(fn => {
@@ -100,7 +102,7 @@ class RuntimeAPI {
   async executeStep(step, agentResolver) {
     switch (step.type) {
       case 'calculate': {
-        // e.g., "add({x}, {y})"
+        // 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;
@@ -112,6 +114,32 @@ class RuntimeAPI {
           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;