@o-lang/olang 1.0.26 → 1.1.1

package/cli.js

@@ -1,12 +1,15 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 const { Command } = require('commander');
 const { parse } = require('./src/parser');
 const { execute } = require('./src/runtime');
 const fs = require('fs');
 const path = require('path');
 
+// === ADDED: Load package.json for version (1 line added) ===
+const pkg = require('./package.json');
+
 /**
- * Enforce .ol extension ONLY
+ * Enforce .ol extension ONLY (CLI only)
  */
 function ensureOlExtension(filename) {
   if (!filename.endsWith('.ol')) {
@@ -22,24 +25,29 @@ function ensureOlExtension(filename) {
  */
 async function defaultMockResolver(action, context) {
   if (!action || typeof action !== 'string') return `[Unhandled: ${String(action)}]`;
+
   if (action.startsWith('Search for ')) {
     return {
       title: "HR Policy 2025",
-      text: "Employees are entitled to 20 days of paid leave per year. All requests must be submitted via the HR portal.",
+      text: "Employees are entitled to 20 days of paid leave per year.",
       url: "mock://hr-policy"
     };
   }
+
   if (action.startsWith('Ask ')) {
-    return " ✅  [Mock] Summarized for demonstration.";
+    return "✅ [Mock] Summarized for demonstration.";
   }
+
   if (action.startsWith('Notify ')) {
     const recipient = action.match(/Notify (\S+)/)?.[1] || 'user@example.com';
-    return ` 📬  Notification sent to ${recipient}`;
+    return `📬 Notification sent to ${recipient}`;
   }
+
   if (action.startsWith('Debrief ') || action.startsWith('Evolve ')) {
     console.log(`[O-Lang] ${action}`);
     return 'Acknowledged';
   }
+
   return `[Unhandled: ${action}]`;
 }
 defaultMockResolver.resolverName = 'defaultMockResolver';
@@ -48,45 +56,43 @@ defaultMockResolver.resolverName = 'defaultMockResolver';
  * Built-in Math Resolver
  */
 async function builtInMathResolver(action, context) {
-  if (!action || typeof action !== 'string') return null;
-  const a = action.replace(/\{([^\}]+)\}/g, (_, k) => {
-    const v = context[k.trim()];
-    return v !== undefined ? v : `{${k}}`;
-  });
+  if (!action || typeof action !== 'string') return undefined;
+
+  const a = action.replace(/\{([^\}]+)\}/g, (_, k) =>
+    context[k.trim()] ?? `{${k}}`
+  );
+
   let m;
-  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);
-  return null;
+  if ((m = a.match(/^add\(([^,]+),\s*([^)]+)\)$/i))) return +m[1] + +m[2];
+  if ((m = a.match(/^subtract\(([^,]+),\s*([^)]+)\)$/i))) return +m[1] - +m[2];
+  if ((m = a.match(/^multiply\(([^,]+),\s*([^)]+)\)$/i))) return +m[1] * +m[2];
+  if ((m = a.match(/^divide\(([^,]+),\s*([^)]+)\)$/i))) return +m[1] / +m[2];
+  if ((m = a.match(/^sum\(\s*\[([^\]]+)\]\s*\)$/i)))
+    return m[1].split(',').map(Number).reduce((a, b) => a + b, 0);
+
+  return undefined;
 }
 builtInMathResolver.resolverName = 'builtInMathResolver';
 
 /**
- * Resolver chaining: returns the FIRST resolver that returns a non-undefined result.
+ * Resolver chaining
  */
 function createResolverChain(resolvers, verbose = false) {
   const wrapped = async (action, context) => {
-    for (let i = 0; i < resolvers.length; i++) {
-      const resolver = resolvers[i];
+    for (const resolver of resolvers) {
       try {
-        const res = await resolver(action, context);
-        if (res !== undefined) {
-          // Store result in context for debugging
-          context[`__resolver_${i}`] = res;
+        const result = await resolver(action, context);
+        if (result !== undefined) {
           if (verbose) {
-            console.log(`[✅ ${resolver.resolverName || 'anonymous'}] handled action`);
+            console.log(`✅ ${resolver.resolverName} handled "${action}"`);
           }
-          return res;
+          return result;
         }
-      } catch (e) {
-        console.error(` ❌  Resolver ${resolver.resolverName || 'anonymous'} failed:`, e.message);
+      } catch (err) {
+        console.error(`❌ Resolver ${resolver.resolverName} failed:`, err.message);
       }
     }
-    if (verbose) {
-      console.log(`[⏭️] No resolver handled action: "${action}"`);
-    }
+    if (verbose) console.log(`⏭️ No resolver handled "${action}"`);
     return undefined;
   };
   wrapped._chain = resolvers;
@@ -94,150 +100,136 @@ function createResolverChain(resolvers, verbose = false) {
 }
 
 /**
- * Load a single resolver — NO fallback to defaultMockResolver
+ * Load a single resolver
  */
 function loadSingleResolver(specifier) {
-  if (!specifier) {
-    throw new Error('Empty resolver specifier provided');
+  if (!specifier) throw new Error('Empty resolver specifier');
+
+  if (specifier.endsWith('.json')) {
+    const manifest = JSON.parse(fs.readFileSync(specifier, 'utf8'));
+    if (manifest.protocol?.startsWith('http')) {
+      const externalResolver = async () => undefined;
+      externalResolver.resolverName = manifest.name;
+      externalResolver.manifest = manifest;
+      console.log(`🌐 Loaded external resolver: ${manifest.name}`);
+      return externalResolver;
+    }
   }
 
-  let resolver, pkgName;
-
-  // Extract clean package name (e.g., @o-lang/extractor → extractor)
-  if (specifier.startsWith('./') || specifier.startsWith('../') || specifier.startsWith('/')) {
-    // Local file: use filename without extension
-    pkgName = path.basename(specifier, path.extname(specifier));
-  } else {
-    // npm package: strip scope (e.g., @o-lang/extractor → extractor)
-    pkgName = specifier.replace(/^@[^/]+\//, '');
-  }
+  let resolver;
+  const pkgName = specifier.startsWith('.') || specifier.startsWith('/')
+    ? path.basename(specifier, path.extname(specifier))
+    : specifier.replace(/^@[^/]+\//, '');
 
   try {
     resolver = require(specifier);
-  } catch (e1) {
-    try {
-      const absolutePath = path.resolve(process.cwd(), specifier);
-      resolver = require(absolutePath);
-      console.log(` 📁  Loaded resolver: ${absolutePath}`);
-    } catch (e2) {
-      throw new Error(
-        `Failed to load resolver '${specifier}':\n  npm: ${e1.message}\n  file: ${e2.message}`
-      );
-    }
+  } catch {
+    resolver = require(path.resolve(process.cwd(), specifier));
   }
 
   if (typeof resolver !== 'function') {
     throw new Error(`Resolver must export a function`);
   }
 
-  // ✅ Auto-assign resolverName from package/filename if missing
-  if (!resolver.resolverName || typeof resolver.resolverName !== 'string') {
-    resolver.resolverName = pkgName;
-    console.log(` 🏷️  Auto-assigned resolverName: "${pkgName}" (from ${specifier})`);
-  } else {
-    console.log(` 📦  Loaded resolver: ${specifier} (name: ${resolver.resolverName})`);
-  }
-
+  resolver.resolverName ||= pkgName;
+  console.log(`📦 Loaded resolver: ${resolver.resolverName}`);
   return resolver;
 }
 
 /**
- * ✅ POLICY-AWARE resolver loader: only includes resolvers in allowedResolvers
+ * Policy-aware resolver loader
  */
-function loadResolverChain(specifiers, verbose = false, allowedResolvers = new Set()) {
-  const userResolvers = specifiers?.map(loadSingleResolver) || [];
+function loadResolverChain(specifiers, verbose, allowed) {
   const resolvers = [];
 
-  // Only add builtInMathResolver if allowed
-  if (allowedResolvers.has('builtInMathResolver')) {
-    resolvers.push(builtInMathResolver);
-  }
+  if (allowed.has('builtInMathResolver')) resolvers.push(builtInMathResolver);
 
-  // Add user resolvers only if their name is allowed
-  for (const r of userResolvers) {
-    const name = r.resolverName || r.name || 'unknown';
-    if (allowedResolvers.has(name)) {
-      resolvers.push(r);
-    } else if (verbose) {
-      console.warn(` ⚠️  Skipping disallowed user resolver: ${name}`);
-    }
+  for (const r of specifiers.map(loadSingleResolver)) {
+    if (allowed.has(r.resolverName)) resolvers.push(r);
+    else if (verbose) console.warn(`⚠️ Skipped disallowed resolver: ${r.resolverName}`);
   }
 
-  // Only add defaultMockResolver if explicitly allowed
-  if (allowedResolvers.has('defaultMockResolver')) {
-    resolvers.push(defaultMockResolver);
-  }
-
-  if (resolvers.length === 0) {
-    if (verbose) {
-      console.warn(' ⚠️  No allowed resolvers loaded. Actions may fail.');
-    }
-  } else {
-    if (verbose) {
-      console.log(` ℹ️  Loaded allowed resolvers: ${resolvers.map(r => r.resolverName || 'anonymous').join(', ')}`);
-    }
-  }
+  if (allowed.has('defaultMockResolver')) resolvers.push(defaultMockResolver);
 
   return createResolverChain(resolvers, verbose);
 }
 
 /**
- * CLI Setup
+ * CLI SETUP
  */
 const program = new Command();
+
+// === ADDED: Version support (1 line added) ===
+program.version(pkg.version, '-V, --version', 'Show O-lang kernel version');
+
+// === RUN COMMAND ===
 program
   .name('olang')
-  .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.',
-    (val, acc) => { acc.push(val); return acc; },
-    []
-  )
-  .option(
-    '-i, --input <k=v>',
-    'Input parameters',
-    (val, acc = {}) => {
-      const [k, v] = val.split('=');
-      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')
+  .option('-r, --resolver <specifier>', 'Resolver', (v, a) => (a.push(v), a), [])
+  .option('-i, --input <k=v>', 'Input', (v, a = {}) => {
+    const [k, val] = v.split('=');
+    a[k] = isNaN(val) ? val : Number(val);
+    return a;
+  }, {})
+  .option('-v, --verbose')
   .action(async (file, options) => {
-    try {
-      ensureOlExtension(file);
-      const content = fs.readFileSync(file, 'utf8');
-      const workflow = parse(content, file);
-      if (!workflow || typeof workflow !== 'object') {
-        console.error(' ❌  Error: Parsed workflow is invalid or empty');
-        process.exit(1);
-      }
-      if (options.verbose) {
-        console.log(' 📄  Parsed Workflow:', JSON.stringify(workflow, null, 2));
-      }
+    ensureOlExtension(file);
+    const workflowSource = fs.readFileSync(file, 'utf8');
+    const workflow = parse(workflowSource, file);
 
-      const allowedSet = new Set(workflow.allowedResolvers.map(r => r.trim()));
-      const resolver = loadResolverChain(options.resolver, options.verbose, allowedSet);
+    const allowed = new Set(workflow.allowedResolvers);
+    const resolver = loadResolverChain(options.resolver, options.verbose, allowed);
 
-      // 🔔 Warn if allowed resolvers declared but none loaded
-      if (workflow.allowedResolvers.length > 0 && resolver._chain.length === 0) {
-        console.warn(
-          `\n⚠️  Warning: Workflow allows [${workflow.allowedResolvers.join(', ')}],\n` +
-          `   but no matching resolvers were loaded. Use -r <path> to provide them.\n`
-        );
+    const result = await execute(workflow, options.input, resolver, options.verbose);
+    console.log(JSON.stringify(result, null, 2));
+  });
+
+// === SERVER COMMAND (✅ PROPER INTEGRATION) ===
+program
+  .command('server')
+  .description('Start O-lang kernel in HTTP server mode')
+  .option('-p, --port <port>', 'Server port', process.env.OLANG_SERVER_PORT || '3000')
+  .option('-h, --host <host>', 'Server host', '0.0.0.0')
+  .action(async (options) => {
+    const fastify = require('fastify')({ logger: false });
+
+    fastify.get('/health', () => ({
+      status: 'healthy',
+      kernel: 'o-lang',
+      uptime: process.uptime()
+    }));
+
+    fastify.post('/execute-workflow', async (req, reply) => {
+      try {
+        const { workflowSource, inputs = {}, resolvers = [], verbose = false } = req.body;
+
+        if (typeof workflowSource !== 'string') {
+          return reply.status(400).send({ error: 'workflowSource must be a string' });
+        }
+
+        const workflow = parse(workflowSource, 'remote.ol');
+        const allowed = new Set(workflow.allowedResolvers);
+        const resolver = loadResolverChain(resolvers, verbose, allowed);
+
+        const result = await execute(workflow, inputs, resolver, verbose);
+        reply.send(result);
+      } catch (err) {
+        reply.status(500).send({ error: err.message });
       }
+    });
 
-      const result = await execute(workflow, options.input, resolver, options.verbose);
-      console.log('\n=== Workflow Result ===');
-      console.log(JSON.stringify(result, null, 2));
+    const PORT = parseInt(options.port, 10);
+    const HOST = options.host;
+
+    try {
+      await fastify.listen({ port: PORT, host: HOST });
+      console.log(`✅ O-Lang Kernel running on http://${HOST}:${PORT}`);
     } catch (err) {
-      console.error(' ❌  Error:', err.message);
+      console.error('❌ Failed to start server:', err);
       process.exit(1);
     }
   });
 
+// === PARSE CLI ===
 program.parse(process.argv);

package/package.json

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