@o-lang/olang 1.0.2 → 1.0.4

package/cli.js

@@ -5,6 +5,21 @@ const { execute } = require('./src/runtime');
 const fs = require('fs');
 const path = require('path');
 
+/**
+ * Enforce .ol extension ONLY
+ */
+function ensureOlExtension(filename) {
+  if (!filename.endsWith('.ol')) {
+    throw new Error(
+      `Invalid file: "${filename}".\n` +
+      `O-Lang workflows must use the ".ol" extension.`
+    );
+  }
+}
+
+/**
+ * Default mock resolver (for demo use)
+ */
 async function defaultMockResolver(action, context) {
   if (action.startsWith('Search for ')) {
     return {
@@ -13,20 +28,55 @@ async function defaultMockResolver(action, context) {
       url: "mock://hr-policy"
     };
   }
+
   if (action.startsWith('Ask ')) {
-    return "✅ [Mock] Summarized for staff.";
+    return "✅ [Mock] Summarized for demonstration.";
   }
+
   if (action.startsWith('Notify ')) {
     const recipient = action.match(/Notify (\S+)/)?.[1] || 'user@example.com';
     return `📬 Notification sent to ${recipient}`;
   }
+
   if (action.startsWith('Debrief ') || action.startsWith('Evolve ')) {
     console.log(`[O-Lang] ${action}`);
     return 'Acknowledged';
   }
+
   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
+ */
 function createResolverChain(resolvers) {
   return async (action, context) => {
     for (const resolver of resolvers) {
@@ -61,42 +111,65 @@ function loadSingleResolver(specifier) {
       console.log(`📁 Loaded resolver: ${absolutePath}`);
       return resolver;
     } catch (e2) {
-      throw new Error(`Failed to load resolver '${specifier}':\n  npm: ${e1.message}\n  file: ${e2.message}`);
+      throw new Error(
+        `Failed to load resolver '${specifier}':\n  npm: ${e1.message}\n  file: ${e2.message}`
+      );
     }
   }
 }
 
+/**
+ * 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);
 }
 
+/**
+ * CLI Setup
+ */
 const program = new Command();
 
 program
   .name('olang')
-  .description('O-Lang CLI: run .olang workflows')
+  .description('O-Lang CLI: run .ol workflows with rule-enforced agent governance')
   .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', (val, acc) => {
-    acc.push(val);
-    return acc;
-  }, [])
-  .option('-i, --input <k=v>', 'Input parameters', (val, acc = {}) => {
-    const [k, v] = val.split('=');
-    acc[k] = v;
-    return acc;
-  }, {})
+  .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',
+    (val, acc) => { acc.push(val); return acc; },
+    []
+  )
+  .option(
+    '-i, --input <k=v>',
+    'Input parameters',
+    (val, acc = {}) => {
+      const [k, v] = val.split('=');
+      acc[k] = isNaN(v) ? v : parseFloat(v);
+      return acc;
+    },
+    {}
+  )
   .action(async (file, options) => {
     try {
+      ensureOlExtension(file);
+
       const content = fs.readFileSync(file, 'utf8');
       const workflow = parse(content);
+
       const resolver = loadResolverChain(options.resolver);
       const result = await execute(workflow, options.input, resolver);
+
       console.log('\n=== Workflow Result ===');
       console.log(JSON.stringify(result, null, 2));
     } catch (err) {
@@ -106,10 +179,3 @@ program
   });
 
 program.parse(process.argv);
-
-
-
-
-
-
-

package/package.json

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

@@ -1,5 +1,11 @@
 // src/parser.js
-function parse(code) {
+
+function parse(code, fileName = null) {
+  // --- New: Enforce .ol extension if filename provided ---
+  if (fileName && !fileName.endsWith(".ol")) {
+    throw new Error(`Expected .ol workflow, got: ${fileName}`);
+  }
+
   const lines = code
     .split(/\r?\n/)
     .map(l => l.trim())
@@ -59,16 +65,11 @@ function parse(code) {
         let key = eq[1].trim();
         let value = eq[2].trim();
 
-        // Parse list: [a, b, c]
         if (value.startsWith('[') && value.endsWith(']')) {
           value = value.slice(1, -1).split(',').map(v => v.trim().replace(/^"/, '').replace(/"$/, ''));
-        }
-        // Parse number
-        else if (!isNaN(value)) {
+        } else if (!isNaN(value)) {
           value = Number(value);
-        }
-        // Keep string (remove quotes if present)
-        else if (value.startsWith('"') && value.endsWith('"')) {
+        } else if (value.startsWith('"') && value.endsWith('"')) {
           value = value.slice(1, -1);
         }
 
@@ -119,7 +120,7 @@ function parse(code) {
       continue;
     }
 
-    // Agent ... uses ...
+    // Agent uses
     const agentUseMatch = line.match(/^Agent\s+"([^"]+)"\s+uses\s+"([^"]+)"$/i);
     if (agentUseMatch) {
       workflow.steps.push({
@@ -199,7 +200,7 @@ function parse(code) {
       continue;
     }
 
-    // --- New: Use <Tool> ---
+    // Use <Tool>
     const useMatch = line.match(/^Use\s+(.+)$/i);
     if (useMatch) {
       workflow.steps.push({
@@ -212,7 +213,7 @@ function parse(code) {
       continue;
     }
 
-    // --- New: Ask <Target> ---
+    // Ask <Target>
     const askMatch = line.match(/^Ask\s+(.+)$/i);
     if (askMatch) {
       workflow.steps.push({
@@ -268,13 +269,11 @@ function parseBlock(lines) {
       steps.push({ type: 'prompt', question: promptMatch[1], saveAs: null });
     }
 
-    // New: Use <Tool>
     const useMatch = line.match(/^Use\s+(.+)$/i);
     if (useMatch) {
       steps.push({ type: 'use', tool: useMatch[1].trim(), saveAs: null, constraints: {} });
     }
 
-    // New: Ask <Target>
     const askMatch = line.match(/^Ask\s+(.+)$/i);
     if (askMatch) {
       steps.push({ type: 'ask', target: askMatch[1].trim(), saveAs: null, constraints: {} });

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;