@o-lang/olang 1.2.28 → 1.2.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@o-lang/olang",
-  "version": "1.2.28",
+  "version": "1.2.30",
   "author": "Olalekan Ogundipe <info@olang.cloud>",
   "description": "O-Lang: A governance language for user-directed, rule-enforced agent workflows",
   "main": "./src/runtime/index.js",

package/src/parser/index.js

@@ -305,6 +305,20 @@ function parseWorkflowLines(lines, filename) {
       continue;
     }
 
+       // ✅ ADD: Set keyword (e.g., Set analysis_result = "")
+    const setMatch = line.match(/^Set\s+(\w+)\s*=\s*(.+)$/i);
+    if (setMatch) {
+      flushCurrentStep();
+      workflow.steps.push({
+        type: 'calculate',
+        stepNumber: workflow.steps.length + 1,
+        actionRaw: setMatch[2].trim(),  // e.g., '""' or '"N/A"'
+        saveAs: setMatch[1].trim(),     // e.g., 'analysis_result'
+        constraints: {}
+      });
+      continue;
+    }
+
     // Debrief
     const debriefMatch = line.match(/^Debrief\s+([^\s]+)\s+with\s+"([^"]*)"$/i);
     if (debriefMatch) {
@@ -589,6 +603,18 @@ function parseBlock(lines) {
       continue;
     }
 
+        // ✅ ADD: Set keyword inside blocks (e.g., Set analysis_result = "")
+    const setMatch = line.match(/^Set\s+(\w+)\s*=\s*(.+)$/i);
+    if (setMatch) {
+      flush(); // Flush any pending step
+      steps.push({
+        type: 'calculate',
+        actionRaw: setMatch[2].trim(),  // e.g., '""' or '"N/A"'
+        saveAs: setMatch[1].trim(),     // e.g., 'analysis_result'
+        constraints: {}
+      });
+      continue;
+    }
     // Fallback
     if (current) {
       current.actionRaw += ' ' + line;  // ← PRESERVED EXACTLY (no normalizeAction)

package/src/runtime/RuntimeAPI.js

@@ -3,7 +3,7 @@ const path = require('path');
 const crypto = require('crypto'); // ✅ CRYPTOGRAPHIC AUDIT LOGS
 
 // ✅ O-Lang Kernel Version (Safety Logic & Governance Rules)
-const KERNEL_VERSION = '1.2.20-alpha'; // 🔁 Update when safety rules change
+const KERNEL_VERSION = '1.2.30-alpha'; // 🔁 Update when safety rules change
 
 class RuntimeAPI {
   constructor({ verbose = false } = {}) {
@@ -638,17 +638,38 @@ class RuntimeAPI {
     return path.split('.').reduce((o, k) => (o && o[k] !== undefined ? o[k] : undefined), obj);
   }
 
-  evaluateCondition(cond, ctx) {
+   evaluateCondition(cond, ctx) {
     cond = cond.trim();
-    const eq = cond.match(/^\{(.+)\}\s+equals\s+"(.*)"$/);
-    if (eq) return this.getNested(ctx, eq[1]) == eq[2];
+
+    // ✅ 1. Handle Logical OR (|| or 'or')
+    if (/\|\||\bor\b/i.test(cond)) {
+      return cond.split(/\|\||\bor\b/i).some(c => this.evaluateCondition(c.trim(), ctx));
+    }
+    // ✅ 2. Handle Logical AND (&& or 'and')
+    if (/&&|\band\b/i.test(cond)) {
+      return cond.split(/&&|\band\b/i).every(c => this.evaluateCondition(c.trim(), ctx));
+    }
+
+    // ✅ 3. Handle == or === (works with or without {})
+    const eqMatch = cond.match(/^(?:\{(.+)\}|(\w+))\s*===?\s*"(.*)"$/);
+    if (eqMatch) {
+      const key = eqMatch[1] || eqMatch[2];
+      return this.getNested(ctx, key) === eqMatch[3];
+    }
+
+    // ✅ 4. Keep original O-Lang syntax
+    const oldEq = cond.match(/^\{(.+)\}\s+equals\s+"(.*)"$/);
+    if (oldEq) return this.getNested(ctx, oldEq[1]) == oldEq[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]);
+
+    // Fallback: truthy check
     return Boolean(this.getNested(ctx, cond.replace(/\{|\}/g, '')));
   }
-
   mathFunctions = {
     add: (a, b) => a + b,
     subtract: (a, b) => a - b,
@@ -857,41 +878,57 @@ class RuntimeAPI {
     if (!output || typeof output !== 'string') return { passed: true };
 
     // ── __verified_intent takes priority ──────────────────────────────────────
-    // If the workflow author has defined intent rules, use those exclusively.
-    // This makes governance dynamic — skip hardcoded patterns entirely.
-    const intent = this.context.__verified_intent;
-    if (intent) {
-      if (intent.prohibited_actions && Array.isArray(intent.prohibited_actions)) {
-        const lower = output.toLowerCase();
-        for (const action of intent.prohibited_actions) {
-          if (lower.includes(action.toLowerCase())) {
-            return {
-              passed: false,
-              reason: `Output violates prohibited action "${action}" defined in __verified_intent`,
-              detected: action,
-              language: 'multi'
-            };
-          }
-        }
+const intent = this.context.__verified_intent;
+if (intent) {
+  if (intent.prohibited_actions && Array.isArray(intent.prohibited_actions)) {
+    const lower = output.toLowerCase();
+    for (const action of intent.prohibited_actions) {
+      if (lower.includes(action.toLowerCase())) {
+        return {
+          passed: false,
+          reason: `Output violates prohibited action "${action}" defined in __verified_intent`,
+          detected: action,
+          language: 'multi'
+        };
       }
+    }
+  }
 
-      if (intent.prohibited_topics && Array.isArray(intent.prohibited_topics)) {
-        const lower = output.toLowerCase();
-        for (const topic of intent.prohibited_topics) {
-          if (lower.includes(topic.toLowerCase())) {
-            return {
-              passed: false,
-              reason: `Output violates prohibited topic "${topic}" defined in __verified_intent`,
-              detected: topic,
-              language: 'multi'
-            };
-          }
+  if (intent.prohibited_topics && Array.isArray(intent.prohibited_topics)) {
+    for (const topic of intent.prohibited_topics) {
+      const isRegex = typeof topic === 'object' && topic.pattern;
+      let matched = false;
+      let detected = '';
+
+      if (isRegex) {
+        try {
+          const re = new RegExp(topic.pattern, topic.flags || 'i');
+          const match = output.match(re);
+          matched = !!match;
+          detected = match ? match[0] : topic.pattern;
+        } catch (e) {
+          this.addWarning(`Invalid prohibited_topic regex: "${topic.pattern}" — ${e.message}`);
+          continue;
         }
+      } else {
+        matched = output.toLowerCase().includes(topic.toLowerCase());
+        detected = topic;
       }
 
-      // __verified_intent present and passed — skip hardcoded patterns
-      return { passed: true };
+      if (matched) {
+        return {
+          passed: false,
+          reason: `Output violates prohibited topic "${isRegex ? topic.pattern : topic}" defined in __verified_intent`,
+          detected,
+          language: 'multi'
+        };
+      }
     }
+  }
+
+  // __verified_intent present and passed — skip hardcoded patterns
+  return { passed: true };
+}
 
     // ── No __verified_intent — fall through to hardcoded patterns ─────────────
     // 🔑 Extract allowed capabilities from workflow allowlist