@o-lang/olang 1.0.5 → 1.0.7

package/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 const { Command } = require('commander');
-const { parse } = require('../src/parser'); // adjusted path if bin vs root
-const { execute } = require('../src/runtime');
+const { parse } = require('./src/parser');
+const { execute } = require('./src/runtime');
 const fs = require('fs');
 const path = require('path');
 
@@ -49,61 +49,47 @@ async function defaultMockResolver(action, context) {
 }
 
 /**
- * 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.
+ * Built-in Math Resolver
  */
 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(/^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) return m[1].split(',').map(s => parseFloat(s.trim())).reduce((s, v) => s + v, 0);
 
-  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
+ * Resolver chaining with verbose + context logging
  */
-function createResolverChain(resolvers) {
-  return async (action, context) => {
-    for (const resolver of resolvers) {
+function createResolverChain(resolvers, verbose = false) {
+  const chain = resolvers.slice();
+  const wrapped = async (action, context) => {
+    let lastResult;
+    for (let i = 0; i < chain.length; i++) {
       try {
-        const result = await resolver(action, context);
-        if (result !== null && result !== undefined) {
-          return result;
-        }
-      } catch (err) {
-        console.error(`❌ Resolver error for action "${action}":`, err.message);
-        throw err;
+        const res = await chain[i](action, context);
+        context[`__resolver_${i}`] = res;
+        lastResult = res;
+      } catch (e) {
+        console.error(`❌ Resolver ${i} failed for action "${action}":`, e.message);
       }
     }
-    return `[Unhandled: ${action}]`;
+    if (verbose) console.log(`[Resolver Chain] action="${action}" lastResult=`, lastResult);
+    return lastResult;
   };
+  wrapped._chain = chain;
+  return wrapped;
 }
 
 function loadSingleResolver(specifier) {
@@ -111,9 +97,7 @@ function loadSingleResolver(specifier) {
 
   try {
     const resolver = require(specifier);
-    if (typeof resolver !== 'function') {
-      throw new Error(`Resolver must export a function`);
-    }
+    if (typeof resolver !== 'function') throw new Error(`Resolver must export a function`);
     console.log(`📦 Loaded resolver: ${specifier}`);
     return resolver;
   } catch (e1) {
@@ -133,7 +117,7 @@ function loadSingleResolver(specifier) {
 /**
  * loadResolverChain: include built-in math resolver first, then user resolvers, then default mock resolver
  */
-function loadResolverChain(specifiers) {
+function loadResolverChain(specifiers, verbose = false) {
   const userResolvers = specifiers?.map(loadSingleResolver) || [];
   const resolvers = [builtInMathResolver, ...userResolvers, defaultMockResolver];
 
@@ -143,7 +127,7 @@ function loadResolverChain(specifiers) {
     console.log(`📦 Loaded user resolvers: ${specifiers.join(', ')}`);
   }
 
-  return createResolverChain(resolvers);
+  return createResolverChain(resolvers, verbose);
 }
 
 /**
@@ -157,7 +141,7 @@ program
   .command('run <file>')
   .option(
     '-r, --resolver <specifier>',
-    'Resolver (npm package or local path). Can be used multiple times.\nExample:\n  -r @o-lang/llm-groq\n  -r @o-lang/notify-telegram',
+    'Resolver (npm package or local path). Can be used multiple times.',
     (val, acc) => { acc.push(val); return acc; },
     []
   )
@@ -166,13 +150,13 @@ program
     'Input parameters',
     (val, acc = {}) => {
       const [k, v] = val.split('=');
-      // 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;
     },
     {}
   )
+  .option('-v, --verbose', 'Verbose mode: logs resolver outputs and context after each step')
   .action(async (file, options) => {
     try {
       ensureOlExtension(file);
@@ -180,8 +164,8 @@ program
       const content = fs.readFileSync(file, 'utf8');
       const workflow = parse(content);
 
-      const resolver = loadResolverChain(options.resolver);
-      const result = await execute(workflow, options.input, resolver);
+      const resolver = loadResolverChain(options.resolver, options.verbose);
+      const result = await execute(workflow, options.input, resolver, options.verbose);
 
       console.log('\n=== Workflow Result ===');
       console.log(JSON.stringify(result, null, 2));

package/package.json

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

@@ -23,7 +23,7 @@ function parse(code, fileName = null) {
     let line = lines[i];
 
     // ============================
-    // NEW: Detect math operations
+    // NEW: Detect math operations..
     // ============================
 
     // Add X and Y

package/src/runtime.js

@@ -1,13 +1,13 @@
-// src/runtime.js
 const fs = require('fs');
 
 class RuntimeAPI {
-  constructor() {
+  constructor({ verbose = false } = {}) {
     this.context = {};
     this.resources = {};
     this.agentMap = {};
     this.events = {};
     this.workflowSteps = []; // store for evolve lookup
+    this.verbose = verbose; // verbose logging flag
   }
 
   on(eventName, cb) {
@@ -47,9 +47,6 @@ class RuntimeAPI {
     return null;
   }
 
-  // --------------------------
-  // Math helper functions
-  // --------------------------
   mathFunctions = {
     add: (a, b) => a + b,
     subtract: (a, b) => a - b,
@@ -71,15 +68,12 @@ class RuntimeAPI {
   };
 
   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 => {
@@ -87,7 +81,6 @@ class RuntimeAPI {
     });
 
     try {
-      // eslint-disable-next-line no-new-func
       const f = new Function(...funcNames, `return ${expr};`);
       return f(...funcNames.map(fn => safeFunc[fn]));
     } catch (e) {
@@ -100,9 +93,33 @@ class RuntimeAPI {
   // Execute workflow step
   // --------------------------
   async executeStep(step, agentResolver) {
-    switch (step.type) {
+    const stepType = step.type;
+
+    // Helper: execute all resolvers for this step action
+    const runAllResolvers = async (action) => {
+      const outputs = [];
+      if (agentResolver && Array.isArray(agentResolver._chain)) {
+        for (let idx = 0; idx < agentResolver._chain.length; idx++) {
+          const resolver = agentResolver._chain[idx];
+          try {
+            const out = await resolver(action, this.context);
+            outputs.push(out);
+            this.context[`__resolver_${idx}`] = out;
+          } catch (e) {
+            console.error(`❌ Resolver ${idx} error for action "${action}":`, e.message);
+            outputs.push(null);
+          }
+        }
+      } else {
+        const out = await agentResolver(action, this.context);
+        outputs.push(out);
+        this.context['__resolver_0'] = out;
+      }
+      return outputs[outputs.length - 1]; // last result as primary
+    };
+
+    switch (stepType) {
       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;
@@ -115,23 +132,16 @@ class RuntimeAPI {
           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;
@@ -139,20 +149,19 @@ class RuntimeAPI {
           }
         }
 
-        // fallback to agent resolver
-        const res = await agentResolver(action, this.context);
+        const res = await runAllResolvers(action);
         if (step.saveAs) this.context[step.saveAs] = res;
         break;
       }
 
       case 'use': {
-        const res = await agentResolver(`Use ${step.tool}`, this.context);
+        const res = await runAllResolvers(`Use ${step.tool}`);
         if (step.saveAs) this.context[step.saveAs] = res;
         break;
       }
 
       case 'ask': {
-        const res = await agentResolver(`Ask ${step.target}`, this.context);
+        const res = await runAllResolvers(`Ask ${step.target}`);
         if (step.saveAs) this.context[step.saveAs] = res;
         break;
       }
@@ -211,7 +220,7 @@ class RuntimeAPI {
             revisedAction = revisedAction.replace(/(")$/, `\n\n[IMPROVEMENT FEEDBACK: ${step.feedback}]$1`);
           }
 
-          currentOutput = await agentResolver(revisedAction, this.context);
+          currentOutput = await runAllResolvers(revisedAction);
           this.context[varName] = currentOutput;
 
           this.emit('debrief', {
@@ -244,6 +253,12 @@ class RuntimeAPI {
         break;
       }
     }
+
+    // Verbose logging of context after each step
+    if (this.verbose) {
+      console.log(`\n[Step: ${step.type} | saveAs: ${step.saveAs || 'N/A'}]`);
+      console.log(JSON.stringify(this.context, null, 2));
+    }
   }
 
   async getUserInput(question) {
@@ -273,8 +288,8 @@ class RuntimeAPI {
   }
 }
 
-async function execute(workflow, inputs, agentResolver) {
-  const rt = new RuntimeAPI();
+async function execute(workflow, inputs, agentResolver, verbose = false) {
+  const rt = new RuntimeAPI({ verbose });
   return rt.executeWorkflow(workflow, inputs, agentResolver);
 }