@o-lang/olang 1.0.14 → 1.0.16

package/package.json

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

@@ -1,12 +1,9 @@
 // src/parser.js
-
 function parse(code, fileName = null) {
   if (fileName && !fileName.endsWith(".ol")) {
     throw new Error(`Expected .ol workflow, got: ${fileName}`);
   }
-
   const rawLines = code.split(/\r?\n/);
-
   const lines = rawLines
     .map(l => l.trim())
     .filter(l => l && !l.startsWith('#') && !l.startsWith('//'));
@@ -17,37 +14,41 @@ function parse(code, fileName = null) {
     steps: [],
     returnValues: [],
     allowedResolvers: [],
-
     resolverPolicy: {
       declared: [],
       autoInjected: [],
       used: [],
       warnings: []
     },
-
     __warnings: [],
     __requiresMath: false
   };
 
   let i = 0;
-
   while (i < lines.length) {
     let line = lines[i];
 
-    const allowMatch = line.match(/^Allow resolvers\s*:\s*$/i);
+    // ✅ FIXED: Match both "Allow resolvers" and "Allowed resolvers"
+    const allowMatch = line.match(/^Allow(?:ed)?\s+resolvers\s*:\s*$/i);
     if (allowMatch) {
       i++;
-      while (i < lines.length && !/^[A-Za-z]/.test(lines[i])) {
-        const val = lines[i].trim();
-        if (val) {
-          workflow.allowedResolvers.push(val);
-          workflow.resolverPolicy.declared.push(val);
+      // Read all subsequent non-empty lines until a new top-level section (starts with capital letter)
+      while (i < lines.length) {
+        const nextLine = lines[i].trim();
+        // Stop if line is empty or appears to be a new top-level keyword (e.g., Step, Workflow, Return)
+        if (nextLine === '' || /^[A-Z][a-z]/.test(nextLine)) {
+          break;
+        }
+        if (nextLine) {
+          workflow.allowedResolvers.push(nextLine);
+          workflow.resolverPolicy.declared.push(nextLine);
         }
         i++;
       }
       continue;
     }
 
+    // ---- Math step patterns (standalone) ----
     let mathAdd = line.match(/^Add\s+\{(.+?)\}\s+and\s+\{(.+?)\}\s+Save as\s+(.+)$/i);
     if (mathAdd) {
       workflow.__requiresMath = true;
@@ -65,7 +66,7 @@ function parse(code, fileName = null) {
       workflow.__requiresMath = true;
       workflow.steps.push({
         type: 'calculate',
-        expression: `subtract({${mathSub[2]}}, {${mathSub[1]}})`,
+        expression: `subtract({${mathAdd[2]}}, {${mathAdd[1]}})`,
         saveAs: mathSub[3].trim()
       });
       i++;
@@ -96,6 +97,7 @@ function parse(code, fileName = null) {
       continue;
     }
 
+    // ---- Workflow declaration ----
     const wfMatch = line.match(/^Workflow\s+"([^"]+)"(?:\s+with\s+(.+))?/i);
     if (wfMatch) {
       workflow.name = wfMatch[1];
@@ -106,96 +108,84 @@ function parse(code, fileName = null) {
       continue;
     }
 
-// ---------------------------
-// Return statement (updated: auto-detect math)
-// ---------------------------
-const returnMatch = line.match(/^Return\s+(.+)$/i);
-if (returnMatch) {
-  const returns = returnMatch[1].split(',').map(v => v.trim());
-  workflow.returnValues = returns;
-
-  // --- Check if any return vars come from math steps ---
-  for (const retVar of returns) {
-    const producedByMath = workflow.steps.some(
-      s => s.saveAs === retVar && s.type === 'calculate'
-    );
-    if (producedByMath) workflow.__requiresMath = true;
-  }
-
-  i++;
-  continue;
-}
-
-
-    // ---------------------------
-// Steps (updated: auto-detect math + saveAs)
-// ---------------------------
-const stepMatch = line.match(/^Step\s+(\d+)\s*:\s*(.+)$/i);
-if (stepMatch) {
-  const stepNum = parseInt(stepMatch[1], 10);
-  const raw = stepMatch[2].trim();
-
-  // --- Detect math inside Step ---
-  let mathDetected = null;
-  let expr = '';
-  let saveVar = null;
-
-  const mathOps = [
-    { re: /^Add\s+\{(.+?)\}\s+and\s+\{(.+?)\}\s+Save as\s+(.+)$/i, fn: 'add' },
-    { re: /^Subtract\s+\{(.+?)\}\s+from\s+\{(.+?)\}\s+Save as\s+(.+)$/i, fn: 'subtract' },
-    { re: /^Multiply\s+\{(.+?)\}\s+and\s+\{(.+?)\}\s+Save as\s+(.+)$/i, fn: 'multiply' },
-    { re: /^Divide\s+\{(.+?)\}\s+by\s+\{(.+?)\}\s+Save as\s+(.+)$/i, fn: 'divide' }
-  ];
-
-  for (const op of mathOps) {
-    const m = raw.match(op.re);
-    if (m) {
-      mathDetected = op.fn;
-      saveVar = m[3].trim();
-      if (op.fn === 'subtract') expr = `subtract({${m[2]}}, {${m[1]}})`;
-      else expr = `${op.fn}({${m[1]}}, {${m[2]}})`;
-      break;
+    // ---- Return statement (updated: auto-detect math) ----
+    const returnMatch = line.match(/^Return\s+(.+)$/i);
+    if (returnMatch) {
+      const returns = returnMatch[1].split(',').map(v => v.trim());
+      workflow.returnValues = returns;
+      // Check if any return vars come from math steps
+      for (const retVar of returns) {
+        const producedByMath = workflow.steps.some(
+          s => s.saveAs === retVar && s.type === 'calculate'
+        );
+        if (producedByMath) workflow.__requiresMath = true;
+      }
+      i++;
+      continue;
     }
-  }
-
-  if (mathDetected) workflow.__requiresMath = true;
-
-  workflow.steps.push({
-    type: mathDetected ? 'calculate' : 'action',
-    stepNumber: stepNum,
-    actionRaw: mathDetected ? null : raw,
-    expression: mathDetected ? expr : undefined,
-    saveAs: saveVar,
-    constraints: {}
-  });
 
-  i++;
-  continue;
-}
+    // ---- Step parsing (with inline math detection) ----
+    const stepMatch = line.match(/^Step\s+(\d+)\s*:\s*(.+)$/i);
+    if (stepMatch) {
+      const stepNum = parseInt(stepMatch[1], 10);
+      const raw = stepMatch[2].trim();
+
+      let mathDetected = null;
+      let expr = '';
+      let saveVar = null;
+      const mathOps = [
+        { re: /^Add\s+\{(.+?)\}\s+and\s+\{(.+?)\}\s+Save as\s+(.+)$/i, fn: 'add' },
+        { re: /^Subtract\s+\{(.+?)\}\s+from\s+\{(.+?)\}\s+Save as\s+(.+)$/i, fn: 'subtract' },
+        { re: /^Multiply\s+\{(.+?)\}\s+and\s+\{(.+?)\}\s+Save as\s+(.+)$/i, fn: 'multiply' },
+        { re: /^Divide\s+\{(.+?)\}\s+by\s+\{(.+?)\}\s+Save as\s+(.+)$/i, fn: 'divide' }
+      ];
+      for (const op of mathOps) {
+        const m = raw.match(op.re);
+        if (m) {
+          mathDetected = op.fn;
+          saveVar = m[3].trim();
+          if (op.fn === 'subtract') {
+            expr = `subtract({${m[2]}}, {${m[1]}})`;
+          } else {
+            expr = `${op.fn}({${m[1]}}, {${m[2]}})`;
+          }
+          break;
+        }
+      }
+      if (mathDetected) workflow.__requiresMath = true;
+      workflow.steps.push({
+        type: mathDetected ? 'calculate' : 'action',
+        stepNumber: stepNum,
+        actionRaw: mathDetected ? null : raw,
+        expression: mathDetected ? expr : undefined,
+        saveAs: saveVar,
+        constraints: {}
+      });
+      i++;
+      continue;
+    }
 
+    // ---- Save as (for legacy or multi-line steps) ----
     const saveMatch = line.match(/^Save as\s+(.+)$/i);
     if (saveMatch && workflow.steps.length > 0) {
       const lastStep = workflow.steps[workflow.steps.length - 1];
       lastStep.saveAs = saveMatch[1].trim();
-
       if (lastStep.saveAs.match(/[A-Z][A-Za-z0-9_]*/)) {
         workflow.__requiresMath = true;
       }
-
       i++;
       continue;
     }
 
+    // ---- Constraint parsing ----
     const constraintMatch = line.match(/^Constraint:\s*(.+)$/i);
     if (constraintMatch && workflow.steps.length > 0) {
       const lastStep = workflow.steps[workflow.steps.length - 1];
       if (!lastStep.constraints) lastStep.constraints = {};
-
       const eq = constraintMatch[1].match(/^([^=]+)=\s*(.+)$/);
       if (eq) {
         let key = eq[1].trim();
         let value = eq[2].trim();
-
         if (value.startsWith('[') && value.endsWith(']')) {
           value = value.slice(1, -1).split(',').map(v =>
             v.trim().replace(/^"/, '').replace(/"$/, '')
@@ -205,7 +195,6 @@ if (stepMatch) {
         } else if (value.startsWith('"') && value.endsWith('"')) {
           value = value.slice(1, -1);
         }
-
         lastStep.constraints[key] = value;
       }
       i++;
@@ -220,7 +209,6 @@ if (stepMatch) {
   // ============================
   if (workflow.__requiresMath) {
     workflow.resolverPolicy.used.push('builtInMathResolver');
-
     if (!workflow.resolverPolicy.declared.includes('builtInMathResolver')) {
       workflow.resolverPolicy.autoInjected.push('builtInMathResolver');
       workflow.allowedResolvers.unshift('builtInMathResolver');
@@ -237,7 +225,6 @@ if (stepMatch) {
   }
 
   workflow.resolverPolicy.warnings = workflow.__warnings.slice();
-
   return workflow;
 }
 
@@ -247,7 +234,6 @@ if (stepMatch) {
 function parseBlock(lines) {
   const steps = [];
   let current = null;
-
   for (const line of lines) {
     const stepMatch = line.match(/^Step\s+(\d+)\s*:\s*(.+)$/i);
     if (stepMatch) {
@@ -261,37 +247,30 @@ function parseBlock(lines) {
       steps.push(current);
       continue;
     }
-
     const saveMatch = line.match(/^Save as\s+(.+)$/i);
     if (saveMatch && current) current.saveAs = saveMatch[1].trim();
-
     const debriefMatch = line.match(/^Debrief\s+(\w+)\s+with\s+"(.+)"$/i);
     if (debriefMatch) {
       steps.push({ type: 'debrief', agent: debriefMatch[1], message: debriefMatch[2] });
     }
-
     const evolveMatch = line.match(/^Evolve\s+(\w+)\s+using\s+feedback:\s+"(.+)"$/i);
     if (evolveMatch) {
       steps.push({ type: 'evolve', agent: evolveMatch[1], feedback: evolveMatch[2] });
     }
-
     const promptMatch = line.match(/^Prompt user to\s+"(.+)"$/i);
     if (promptMatch) {
       steps.push({ type: 'prompt', question: promptMatch[1], saveAs: null });
     }
-
     const useMatch = line.match(/^Use\s+(.+)$/i);
     if (useMatch) {
       steps.push({ type: 'use', tool: useMatch[1].trim(), saveAs: null, constraints: {} });
     }
-
     const askMatch = line.match(/^Ask\s+(.+)$/i);
     if (askMatch) {
       steps.push({ type: 'ask', target: askMatch[1].trim(), saveAs: null, constraints: {} });
     }
   }
-
   return steps;
 }
 
-module.exports = { parse };
+module.exports = { parse };

package/src/runtime.js

@@ -86,7 +86,7 @@ class RuntimeAPI {
     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]);
+    if (lt) return parseFloat(this.getNested(ctx, lt[1])) < parseFloat(gt[2]);
     return Boolean(this.getNested(ctx, cond.replace(/\{|\}/g, '')));
   }
 
@@ -144,31 +144,37 @@ class RuntimeAPI {
   async executeStep(step, agentResolver) {
     const stepType = step.type;
 
-   const validateResolver = (resolver) => {
-  const resolverName = (resolver?.resolverName || resolver?.name || '').trim();
-  if (!resolverName) throw new Error('[O-Lang] Resolver missing name metadata');
+    const validateResolver = (resolver) => {
+      const resolverName = (resolver?.resolverName || resolver?.name || '').trim();
+      if (!resolverName) throw new Error('[O-Lang] Resolver missing name metadata');
 
-  const allowed = Array.from(this.allowedResolvers || []).map(r => r.trim());
-
-  // Auto-inject builtInMathResolver if step type is 'calculate' and resolver is math
-  if (step.type === 'calculate' && resolverName === 'builtInMathResolver' && !allowed.includes('builtInMathResolver')) {
-    this.allowedResolvers.add('builtInMathResolver');
-    allowed.push('builtInMathResolver');
-  }
-
-  if (!allowed.includes(resolverName)) {
-    this.logDisallowedResolver(resolverName, step.actionRaw || step.tool || step.target);
-    throw new Error(`[O-Lang] Resolver "${resolverName}" is not allowed by workflow policy`);
-  }
-};
+      const allowed = Array.from(this.allowedResolvers || []).map(r => r.trim());
 
+      if (!allowed.includes(resolverName)) {
+        this.logDisallowedResolver(resolverName, step.actionRaw || step.tool || step.target);
+        throw new Error(`[O-Lang] Resolver "${resolverName}" is not allowed by workflow policy`);
+      }
+    };
 
     const runResolvers = async (action) => {
       const outputs = [];
+
+      const mathPattern =
+        /^(Add|Subtract|Multiply|Divide|Sum|Avg|Min|Max|Round|Floor|Ceil|Abs)\b/i;
+
+      if (
+        step.actionRaw &&
+        mathPattern.test(step.actionRaw) &&
+        !this.allowedResolvers.has('builtInMathResolver')
+      ) {
+        this.allowedResolvers.add('builtInMathResolver');
+      }
+
       if (agentResolver && Array.isArray(agentResolver._chain)) {
         for (let idx = 0; idx < agentResolver._chain.length; idx++) {
           const resolver = agentResolver._chain[idx];
           validateResolver(resolver);
+
           try {
             const out = await resolver(action, this.context);
             outputs.push(out);
@@ -184,16 +190,17 @@ class RuntimeAPI {
         outputs.push(out);
         this.context['__resolver_0'] = out;
       }
+
       return outputs[outputs.length - 1];
     };
 
-    // --- execute based on step.type ---
     switch (stepType) {
       case 'calculate': {
         const result = this.evaluateMath(step.expression || step.actionRaw);
         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());
@@ -203,11 +210,10 @@ class RuntimeAPI {
         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];
-          const args = argsRaw.split(',').map(s => s.trim()).map(s => {
-            if (/^".*"$/.test(s) || /^'.*'$/.test(s)) return s.slice(1, -1);
+          const args = mathCall[2].split(',').map(s => {
+            s = s.trim();
             if (!isNaN(s)) return parseFloat(s);
-            return this.getNested(this.context, s.replace(/^\{|\}$/g, '').trim());
+            return this.getNested(this.context, s.replace(/^\{|\}$/g, ''));
           });
           if (this.mathFunctions[fn]) {
             const value = this.mathFunctions[fn](...args);
@@ -220,79 +226,45 @@ class RuntimeAPI {
         if (step.saveAs) this.context[step.saveAs] = res;
         break;
       }
+
       case 'use': {
         const res = await runResolvers(`Use ${step.tool}`);
         if (step.saveAs) this.context[step.saveAs] = res;
         break;
       }
+
       case 'ask': {
         const res = await runResolvers(`Ask ${step.target}`);
         if (step.saveAs) this.context[step.saveAs] = res;
         break;
       }
+
       case 'if': {
         if (this.evaluateCondition(step.condition, this.context)) {
           for (const s of step.body) await this.executeStep(s, agentResolver);
         }
         break;
       }
+
       case 'parallel': {
         await Promise.all(step.steps.map(s => this.executeStep(s, agentResolver)));
         break;
       }
+
       case 'connect': {
         this.resources[step.resource] = step.endpoint;
         break;
       }
+
       case 'agent_use': {
         this.agentMap[step.logicalName] = step.resource;
         break;
       }
+
       case 'debrief': {
         this.emit('debrief', { agent: step.agent, message: step.message });
         break;
       }
-      case 'evolve': {
-        const maxGen = step.constraints?.max_generations || 1;
-        if (maxGen < 1) return;
-        const summaryStep = this.findLastSummaryStep();
-        if (!summaryStep) {
-          this.addWarning('Evolve step has no prior "Ask ... Save as" step to evolve');
-          return;
-        }
-        const varName = summaryStep.saveAs;
-        let currentOutput = this.context[varName] || '';
-        for (let attempt = 0; attempt < maxGen; attempt++) {
-          let revisedAction = summaryStep.actionRaw.replace(/\{([^\}]+)\}/g, (_, path) => {
-            const val = this.getNested(this.context, path.trim());
-            return val !== undefined ? String(val) : `{${path}}`;
-          });
-          if (step.feedback) revisedAction += `\n[IMPROVEMENT FEEDBACK: ${step.feedback}]`;
-          currentOutput = await runResolvers(revisedAction);
-          this.context[varName] = currentOutput;
-          this.emit('debrief', {
-            agent: step.agent || 'Evolver',
-            message: `Evolve attempt ${attempt + 1}/${maxGen}: ${currentOutput.substring(0, 80)}...`
-          });
-        }
-        this.context['improved_summary'] = currentOutput;
-        break;
-      }
-      case 'prompt': {
-        const input = await this.getUserInput(step.question);
-        if (step.saveAs) this.context[step.saveAs] = input;
-        break;
-      }
-      case 'persist': {
-        const val = this.context[step.variable];
-        if (val !== undefined) fs.appendFileSync(step.target, JSON.stringify(val) + '\n', 'utf8');
-        break;
-      }
-      case 'emit': {
-        const payload = step.payload ? this.getNested(this.context, step.payload) : undefined;
-        this.emit(step.event, payload || step.payload);
-        break;
-      }
     }
 
     if (this.verbose) {
@@ -301,23 +273,23 @@ class RuntimeAPI {
     }
   }
 
-  async getUserInput(question) {
-    return new Promise(resolve => {
-      process.stdout.write(`${question}: `);
-      process.stdin.resume();
-      process.stdin.once('data', data => {
-        process.stdin.pause();
-        resolve(data.toString().trim());
-      });
-    });
-  }
-
   async executeWorkflow(workflow, inputs, agentResolver) {
     this.context = { ...inputs };
     this.workflowSteps = workflow.steps;
     this.allowedResolvers = new Set(workflow.allowedResolvers || []);
 
-    for (const step of workflow.steps) await this.executeStep(step, agentResolver);
+    const mathPattern =
+      /^(Add|Subtract|Multiply|Divide|Sum|Avg|Min|Max|Round|Floor|Ceil|Abs)\b/i;
+
+    for (const step of workflow.steps) {
+      if (step.type === 'calculate' || (step.actionRaw && mathPattern.test(step.actionRaw))) {
+        this.allowedResolvers.add('builtInMathResolver');
+      }
+    }
+
+    for (const step of workflow.steps) {
+      await this.executeStep(step, agentResolver);
+    }
 
     this.printDisallowedSummary();