@o-lang/olang 1.0.20 → 1.0.22

package/cli.js

@@ -64,25 +64,32 @@ async function builtInMathResolver(action, context) {
 builtInMathResolver.resolverName = 'builtInMathResolver';
 
 /**
- * Resolver chaining with verbose + context logging
+ * Resolver chaining: returns the FIRST resolver that returns a non-undefined result.
  */
 function createResolverChain(resolvers, verbose = false) {
-  const chain = resolvers.slice();
   const wrapped = async (action, context) => {
-    let lastResult;
-    for (let i = 0; i < chain.length; i++) {
+    for (let i = 0; i < resolvers.length; i++) {
+      const resolver = resolvers[i];
       try {
-        const res = await chain[i](action, context);
-        context[`__resolver_${i}`] = res;
-        lastResult = res;
+        const res = await resolver(action, context);
+        if (res !== undefined) {
+          // Store result in context for debugging
+          context[`__resolver_${i}`] = res;
+          if (verbose) {
+            console.log(`[✅ ${resolver.resolverName || 'anonymous'}] handled action`);
+          }
+          return res;
+        }
       } catch (e) {
-        console.error(` ❌  Resolver ${i} failed for action "${action}":`, e.message);
+        console.error(` ❌  Resolver ${resolver.resolverName || 'anonymous'} failed:`, e.message);
       }
     }
-    if (verbose) console.log(`[Resolver Chain] action="${action}" lastResult=`, lastResult);
-    return lastResult;
+    if (verbose) {
+      console.log(`[⏭️] No resolver handled action: "${action}"`);
+    }
+    return undefined;
   };
-  wrapped._chain = chain;
+  wrapped._chain = resolvers;
   return wrapped;
 }
 

package/package.json

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

@@ -29,25 +29,50 @@ function parse(code, fileName = null) {
     let line = lines[i];
 
     // ✅ FIXED: Match both "Allow resolvers" and "Allowed resolvers"
-    const allowMatch = line.match(/^Allow(?:ed)?\s+resolvers\s*:\s*$/i);
+    const allowMatch = line.match(/^Allow resolvers\s*:\s*$/i);
     if (allowMatch) {
       i++;
-      // 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)
+        // Stop if line is empty or looks like a new top-level section
         if (nextLine === '' || /^[A-Z][a-z]/.test(nextLine)) {
           break;
         }
-        if (nextLine) {
-          workflow.allowedResolvers.push(nextLine);
-          workflow.resolverPolicy.declared.push(nextLine);
+        // Strip optional YAML list marker: "- name" → "name"
+        const cleanVal = nextLine.replace(/^\-\s*/, '').trim();
+        if (cleanVal) {
+          workflow.allowedResolvers.push(cleanVal);
+          workflow.resolverPolicy.declared.push(cleanVal);
         }
         i++;
       }
       continue;
     }
 
+    // ✅ NEW: Parse database Persist steps
+    const dbPersistMatch = line.match(/^Persist\s+([^\s]+)\s+to\s+db:([^\s]+)$/i);
+    if (dbPersistMatch) {
+      workflow.steps.push({
+        type: 'persist-db',
+        source: dbPersistMatch[1].trim(),
+        collection: dbPersistMatch[2].trim()
+      });
+      i++;
+      continue;
+    }
+
+    // ✅ Parse file Persist steps
+    const persistMatch = line.match(/^Persist\s+([^\s]+)\s+to\s+"([^"]+)"$/i);
+    if (persistMatch) {
+      workflow.steps.push({
+        type: 'persist',
+        source: persistMatch[1].trim(),
+        destination: persistMatch[2].trim()
+      });
+      i++;
+      continue;
+    }
+
     // ---- Math step patterns (standalone) ----
     let mathAdd = line.match(/^Add\s+\{(.+?)\}\s+and\s+\{(.+?)\}\s+Save as\s+(.+)$/i);
     if (mathAdd) {
@@ -66,7 +91,7 @@ function parse(code, fileName = null) {
       workflow.__requiresMath = true;
       workflow.steps.push({
         type: 'calculate',
-        expression: `subtract({${mathAdd[2]}}, {${mathAdd[1]}})`,
+        expression: `subtract({${mathSub[2]}}, {${mathSub[1]}})`, // Fixed: was mathAdd
         saveAs: mathSub[3].trim()
       });
       i++;
@@ -229,7 +254,7 @@ function parse(code, fileName = null) {
 }
 
 // ---------------------------
-// Parse nested blocks (unchanged)
+// Parse nested blocks (updated)
 // ---------------------------
 function parseBlock(lines) {
   const steps = [];
@@ -269,6 +294,24 @@ function parseBlock(lines) {
     if (askMatch) {
       steps.push({ type: 'ask', target: askMatch[1].trim(), saveAs: null, constraints: {} });
     }
+    // ✅ Parse file Persist in blocks
+    const persistMatch = line.match(/^Persist\s+([^\s]+)\s+to\s+"([^"]+)"$/i);
+    if (persistMatch) {
+      steps.push({
+        type: 'persist',
+        source: persistMatch[1].trim(),
+        destination: persistMatch[2].trim()
+      });
+    }
+    // ✅ NEW: Parse database Persist in blocks
+    const dbPersistMatch = line.match(/^Persist\s+([^\s]+)\s+to\s+db:([^\s]+)$/i);
+    if (dbPersistMatch) {
+      steps.push({
+        type: 'persist-db',
+        source: dbPersistMatch[1].trim(),
+        collection: dbPersistMatch[2].trim()
+      });
+    }
   }
   return steps;
 }

package/src/runtime.js

@@ -16,6 +16,80 @@ class RuntimeAPI {
     if (!fs.existsSync(logsDir)) fs.mkdirSync(logsDir, { recursive: true });
     this.disallowedLogFile = path.join(logsDir, 'disallowed_resolvers.json');
     this.disallowedAttempts = [];
+
+    // ✅ NEW: Database client setup
+    this.dbClient = null;
+    this._initDbClient();
+  }
+
+  // ✅ NEW: Initialize database client
+  _initDbClient() {
+    const dbType = process.env.OLANG_DB_TYPE; // 'postgres', 'mysql', 'mongodb', 'sqlite'
+    
+    if (!dbType) return; // DB persistence disabled
+
+    try {
+      switch (dbType.toLowerCase()) {
+        case 'postgres':
+        case 'postgresql':
+          const { Pool } = require('pg');
+          this.dbClient = {
+            type: 'postgres',
+            client: new Pool({
+              host: process.env.DB_HOST || 'localhost',
+              port: parseInt(process.env.DB_PORT) || 5432,
+              user: process.env.DB_USER,
+              password: process.env.DB_PASSWORD,
+              database: process.env.DB_NAME
+            })
+          };
+          break;
+          
+        case 'mysql':
+          const mysql = require('mysql2/promise');
+          this.dbClient = {
+            type: 'mysql',
+            client: mysql.createPool({
+              host: process.env.DB_HOST || 'localhost',
+              port: parseInt(process.env.DB_PORT) || 3306,
+              user: process.env.DB_USER,
+              password: process.env.DB_PASSWORD,
+              database: process.env.DB_NAME
+            })
+          };
+          break;
+          
+        case 'mongodb':
+          const { MongoClient } = require('mongodb');
+          const uri = process.env.MONGO_URI || `mongodb://${process.env.DB_HOST || 'localhost'}:${process.env.DB_PORT || 27017}`;
+          this.dbClient = {
+            type: 'mongodb',
+            client: new MongoClient(uri)
+          };
+          break;
+          
+        case 'sqlite':
+          const Database = require('better-sqlite3');
+          const dbPath = process.env.SQLITE_PATH || './olang.db';
+          const dbDir = path.dirname(path.resolve(dbPath));
+          if (!fs.existsSync(dbDir)) fs.mkdirSync(dbDir, { recursive: true });
+          this.dbClient = {
+            type: 'sqlite',
+            client: new Database(dbPath)
+          };
+          break;
+          
+        default:
+          throw new Error(`Unsupported database type: ${dbType}`);
+      }
+      
+      if (this.verbose) {
+        console.log(`🗄️  Database client initialized: ${dbType}`);
+      }
+    } catch (e) {
+      this.addWarning(`Failed to initialize DB client: ${e.message}`);
+      this.dbClient = null;
+    }
   }
 
   // -----------------------------
@@ -86,7 +160,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(gt[2]);
+    if (lt) return parseFloat(this.getNested(ctx, lt[1])) < parseFloat(lt[2]);
     return Boolean(this.getNested(ctx, cond.replace(/\{|\}/g, '')));
   }
 
@@ -265,6 +339,95 @@ class RuntimeAPI {
         this.emit('debrief', { agent: step.agent, message: step.message });
         break;
       }
+
+      // ✅ File Persist step handler
+      case 'persist': {
+        const sourceValue = this.getNested(this.context, step.source);
+        if (sourceValue === undefined) {
+          this.addWarning(`Cannot persist undefined value from "${step.source}" to "${step.destination}"`);
+          break;
+        }
+
+        const outputPath = path.resolve(process.cwd(), step.destination);
+        const outputDir = path.dirname(outputPath);
+        if (!fs.existsSync(outputDir)) {
+          fs.mkdirSync(outputDir, { recursive: true });
+        }
+
+        let content;
+        if (step.destination.endsWith('.json')) {
+          content = JSON.stringify(sourceValue, null, 2);
+        } else {
+          content = String(sourceValue);
+        }
+
+        fs.writeFileSync(outputPath, content, 'utf8');
+
+        if (this.verbose) {
+          console.log(`💾 Persisted "${step.source}" to ${step.destination}`);
+        }
+        break;
+      }
+
+      // ✅ NEW: Database persist handler
+      case 'persist-db': {
+        if (!this.dbClient) {
+          this.addWarning(`DB persistence skipped (no DB configured). Set OLANG_DB_TYPE env var.`);
+          break;
+        }
+
+        const sourceValue = this.getNested(this.context, step.source);
+        if (sourceValue === undefined) {
+          this.addWarning(`Cannot persist undefined value from "${step.source}" to DB collection "${step.collection}"`);
+          break;
+        }
+
+        try {
+          switch (this.dbClient.type) {
+            case 'postgres':
+            case 'mysql':
+              if (this.dbClient.type === 'postgres') {
+                await this.dbClient.client.query(
+                  `INSERT INTO "${step.collection}" (workflow_name, data, created_at) VALUES ($1, $2, NOW())`,
+                  [this.context.workflow_name || 'unknown', JSON.stringify(sourceValue)]
+                );
+              } else {
+                await this.dbClient.client.execute(
+                  `INSERT INTO ?? (workflow_name, data, created_at) VALUES (?, ?, NOW())`,
+                  [step.collection, this.context.workflow_name || 'unknown', JSON.stringify(sourceValue)]
+                );
+              }
+              break;
+              
+            case 'mongodb':
+              const db = this.dbClient.client.db(process.env.DB_NAME || 'olang');
+              await db.collection(step.collection).insertOne({
+                workflow_name: this.context.workflow_name || 'unknown',
+                 sourceValue,
+                created_at: new Date()
+              });
+              break;
+              
+            case 'sqlite':
+              const stmt = this.dbClient.client.prepare(
+                `INSERT INTO ${step.collection} (workflow_name, data, created_at) VALUES (?, ?, ?)`
+              );
+              stmt.run(
+                this.context.workflow_name || 'unknown',
+                JSON.stringify(sourceValue),
+                new Date().toISOString()
+              );
+              break;
+          }
+          
+          if (this.verbose) {
+            console.log(`🗄️  Persisted "${step.source}" to DB collection ${step.collection}`);
+          }
+        } catch (e) {
+          this.addWarning(`DB persist failed for "${step.source}": ${e.message}`);
+        }
+        break;
+      }
     }
 
     if (this.verbose) {
@@ -274,7 +437,11 @@ class RuntimeAPI {
   }
 
   async executeWorkflow(workflow, inputs, agentResolver) {
-    this.context = { ...inputs };
+    // ✅ Inject workflow name into context
+    this.context = { 
+      ...inputs, 
+      workflow_name: workflow.name 
+    };
     this.workflowSteps = workflow.steps;
     this.allowedResolvers = new Set(workflow.allowedResolvers || []);
 
@@ -313,4 +480,4 @@ async function execute(workflow, inputs, agentResolver, verbose = false) {
   return rt.executeWorkflow(workflow, inputs, agentResolver);
 }
 
-module.exports = { execute, RuntimeAPI };
+module.exports = { execute, RuntimeAPI };