@fnet/cli 0.2.0

package/template/fnet/node/src/cli/index.js.njk

@@ -0,0 +1,319 @@
+{% if atom.doc.features.cli.enabled===true %}
+
+{# Define macros for reusable code blocks #}
+{% macro importMcpDependencies() %}
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import express from "express";
+{% endmacro %}
+
+{% macro mcpModeCodeExtended(runFn) %}
+  if (cliMode === 'mcp') {
+    // MCP mode code
+    const server = new Server({
+      name: "{{atom.doc.features.cli.mcp.name or atom.doc.name}}",
+      version: "{{atom.doc.version or '0.0.1'}}"
+    }, {
+      capabilities: {
+        tools: {}
+      }
+    });
+
+    // Define available tools
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return {
+        tools: [{
+          name: "{{atom.doc.features.cli.mcp.tool.name or atom.doc.name}}",
+          description: "{{atom.doc.features.cli.mcp.tool.description or atom.doc.description}}",
+          inputSchema: inputSchema,
+        }]
+      };
+    });
+
+    // Handle tool execution
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      if (request.params.name === "{{atom.doc.features.cli.mcp.tool.name or atom.doc.name}}") {
+        try {
+          const result = await {{ runFn }}(request.params.arguments, { Engine });
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify(result)
+            }]
+          };
+        } catch (error) {
+          return {
+            content: [{
+              type: "text",
+              text: `Error: ${error.message}`
+            }],
+            isError: true
+          };
+        }
+      }
+      throw new Error("Tool not found");
+    });
+
+    // Get transport type from arguments
+    const transportType = args['mcp-transport'] || args.mcp_transport || 'stdio';
+    let transport;
+
+    if (transportType === 'stdio') {
+      // Use stdio transport
+      transport = new StdioServerTransport();
+    } else if (transportType === 'sse') {
+      // Use SSE transport
+      const app = express();
+      app.use(express.json());
+
+      const port = args['cli-port'] || args.cli_port || 3000;
+      const server = app.listen(port, () => {
+        console.log(`MCP server started with SSE transport on port ${port}`);
+      });
+
+      transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => Math.random().toString(36).substring(2, 15),
+      });
+
+      app.post('/sse', async (req, res) => {
+        await transport.handleRequest(req, res, req.body);
+      });
+
+      app.get('/sse', async (req, res) => {
+        await transport.handleRequest(req, res);
+      });
+
+      app.delete('/sse', async (req, res) => {
+        await transport.handleRequest(req, res);
+      });
+    } else {
+      console.error(`Unknown MCP transport type: ${transportType}`);
+      console.error(`Supported types: stdio, sse`);
+      process.exit(1);
+    }
+
+    await server.connect(transport);
+    return;
+  }
+{% endmacro %}
+
+{% macro mcpModeCodeEngine(engineVar) %}
+  if (cliMode === 'mcp') {
+    // MCP mode code
+    const server = new Server({
+      name: "{{atom.doc.features.cli.mcp.name or atom.doc.name}}",
+      version: "{{atom.doc.version or '0.0.1'}}"
+    }, {
+      capabilities: {
+        tools: {}
+      }
+    });
+
+    // Define available tools
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return {
+        tools: [{
+          name: "{{atom.doc.features.cli.mcp.tool.name or atom.doc.name}}",
+          description: "{{atom.doc.features.cli.mcp.tool.description or atom.doc.description}}",
+          inputSchema: inputSchema,
+        }]
+      };
+    });
+
+    // Handle tool execution
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      if (request.params.name === "{{atom.doc.features.cli.mcp.tool.name or atom.doc.name}}") {
+        try {
+          const result = await {{ engineVar }}.run(request.params.arguments);
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify(result)
+            }]
+          };
+        } catch (error) {
+          return {
+            content: [{
+              type: "text",
+              text: `Error: ${error.message}`
+            }],
+            isError: true
+          };
+        }
+      }
+      throw new Error("Tool not found");
+    });
+
+    // Note: Direct access to workflow nodes is not implemented in this version
+    // In a future version, we could expose workflow nodes as separate MCP tools
+
+    // Get transport type from arguments
+    const transportType = args['mcp-transport'] || args.mcp_transport || 'stdio';
+    let transport;
+
+    if (transportType === 'stdio') {
+      // Use stdio transport
+      transport = new StdioServerTransport();
+    } else if (transportType === 'sse') {
+      // Use SSE transport
+      const app = express();
+      app.use(express.json());
+
+      const port = args['cli-port'] || args.cli_port || 3000;
+      const server = app.listen(port, () => {
+        console.log(`MCP server started with SSE transport on port ${port}`);
+      });
+
+      transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => Math.random().toString(36).substring(2, 15),
+      });
+
+      app.post('/sse', async (req, res) => {
+        await transport.handleRequest(req, res, req.body);
+      });
+
+      app.get('/sse', async (req, res) => {
+        await transport.handleRequest(req, res);
+      });
+
+      app.delete('/sse', async (req, res) => {
+        await transport.handleRequest(req, res);
+      });
+    } else {
+      console.error(`Unknown MCP transport type: ${transportType}`);
+      console.error(`Supported types: stdio, sse`);
+      process.exit(1);
+    }
+
+    await server.connect(transport);
+    return;
+  }
+{% endmacro %}
+
+{% macro httpModeCodeExpress(runFn, engineParam) %}
+  if (cliMode === 'http') {
+    // HTTP mode code using Express
+    const app = express();
+    app.use(express.json());
+
+    app.post('/{{atom.doc.features.cli.http.path or atom.doc.name}}', async (req, res) => {
+      try {
+        const result = await {{ runFn }}(req.body{{ engineParam }});
+        res.json(result);
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+
+    const port = args['cli-port'] || args.cli_port || 3000;
+    app.listen(port, () => {
+      console.log(`HTTP server started on port ${port}`);
+    });
+    return;
+  }
+{% endmacro %}
+
+{% macro defaultModeExtended() %}
+  if (cliMode === 'default') {
+    // Default mode code
+    return await runExtended(await argv(), { Engine });
+  }
+{% endmacro %}
+
+{% macro defaultModeEngine(engineVar) %}
+  if (cliMode === 'default') {
+    // Default mode code
+    const result = await {{ engineVar }}.run(await argv());
+
+    if (typeof result !== 'undefined') {
+      const stdout_format = args['stdout-format'] || args.stdout_format || null;
+
+      if (stdout_format === 'json') console.log(JSON.stringify(result, null, 2));
+      else console.log(result);
+    }
+    return;
+  }
+{% endmacro %}
+
+{% macro runWithCatch() %}
+run()
+  .catch((error) => {
+    console.error(error.message);
+    process.exit(1);
+  });
+{% endmacro %}
+
+{% macro runWithThenCatch() %}
+run()
+  .then(() => {
+    {# process.exit(0); #}
+  })
+  .catch((error) => {
+    console.error(error.message);
+    process.exit(1);
+  });
+{% endmacro %}
+
+{# Main template starts here #}
+import argv from '../default/input.args.js';
+import { schema as inputSchema } from '../default/validate_input.js';
+import { default as Engine } from '../default/{{atom.doc.features.cli_default_entry_file or atom.doc.features.main_default_entry_file}}';
+
+{% if atom.doc.features.cli.mcp.enabled===true %}
+{{ importMcpDependencies() }}
+{% elif atom.doc.features.cli.http.enabled===true %}
+// Using express for HTTP mode
+import express from 'express';
+{% endif %}
+
+{% if atom.doc.features.cli.extend===true %}
+  {# TYPE 1 #}
+  import { default as runExtended } from '../../../cli/index.js';
+  import argsParser from 'yargs-parser';
+
+  const run = async () => {
+    const args = argsParser(process.argv.slice(2));
+    const cliMode = args['cli-mode'] || args.cli_mode || 'default';
+
+    {{ defaultModeExtended() }}
+
+    {% if atom.doc.features.cli.mcp.enabled===true %}
+    {{ mcpModeCodeExtended('runExtended') }}
+    {% endif %}
+
+    {% if atom.doc.features.cli.http.enabled===true %}
+    {{ httpModeCodeExpress('runExtended', ', { Engine }') }}
+    {% endif %}
+
+    console.error(`Unknown CLI mode: ${cliMode}`);
+    process.exit(1);
+  };
+
+  {{ runWithThenCatch() }}
+{% else %}
+  {# TYPE 2 #}
+  import argsParser from 'yargs-parser';
+  const run = async () => {
+    const args =argsParser(process.argv.slice(2));
+    const cliMode = args['cli-mode'] || args.cli_mode || 'default';
+    const engine = new Engine();
+
+    {{ defaultModeEngine('engine') }}
+
+    {% if atom.doc.features.cli.mcp.enabled===true %}
+    {{ mcpModeCodeEngine('engine') }}
+    {% endif %}
+
+    {% if atom.doc.features.cli.http.enabled===true %}
+    {{ httpModeCodeExpress('engine.run', '') }}
+    {% endif %}
+
+    console.error(`Unknown CLI mode: ${cliMode}`);
+    process.exit(1);
+  };
+
+  {{ runWithCatch() }}
+{% endif %}
+{% endif %}

package/template/fnet/node/src/default/blocks/assign.js.njk

@@ -0,0 +1,53 @@
+{% include "src/default/macros/block-header.js.njk" %}
+
+{% include "src/default/macros/block-next-header.js.njk" %}
+
+{% include "src/default/macros/block-modules-header.js.njk" %}
+
+export default function Block(context){
+
+  {% include "src/default/macros/block-body-header.js.njk" %}
+
+  this.run= function (){
+      
+    {% include "src/default/macros/block-entry-args.js.njk" %}
+
+    return new Promise(async (resolve,reject)=>{
+                  
+      {% include "src/default/macros/block-run-header.js.njk" %}
+
+      {% include "src/default/macros/page.js.njk" %}
+
+      {% include "src/default/macros/block-modules.js.njk" %}
+
+      {% if context.next and context.transform.wait==='next' %}
+        flow.waitForNext({
+          key:'{{indexKey}}',
+          next: async () =>  {
+              {% include "src/default/macros/block-next.js.njk" %}
+          }
+        });
+      {% endif %}
+
+      {% for assign in context.transform.assign %}
+      flow.set({{assign.key | safe}},{{assign.value | safe}});
+      {% endfor%}
+
+      {% include "src/default/macros/block-signal.js.njk" %}
+
+      {% if context.transform.return %}
+        resolve({type:'return',value: {{context.transform.return | safe}}});
+      {% elseif context.next and context.transform.wait!=='next'%}
+        {% include "src/default/macros/block-next.js.njk" %}
+      {% elseif not context.next%}
+        resolve();
+      {% endif %}
+
+      {% include "src/default/macros/block-run-footer.js.njk" %}
+    });
+  }
+
+  Object.freeze(this);
+}
+
+{% include "src/default/macros/block-footer.js.njk" %}

package/template/fnet/node/src/default/blocks/call.js.njk

@@ -0,0 +1,156 @@
+{% include "src/default/macros/block-header.js.njk" %}
+
+{% include "src/default/macros/block-next-header.js.njk" %}
+
+{% include "src/default/macros/block-library-header.js.njk" %}
+
+{% include "src/default/macros/block-modules-header.js.njk" %}
+
+export default function Block(context){
+
+  {% include "src/default/macros/block-body-header.js.njk" %}
+  
+  this.run= function (){
+      
+    {% include "src/default/macros/block-entry-args.js.njk" %}
+
+    return new Promise(async (resolve,reject)=>{
+
+
+      try{
+        {% include "src/default/macros/block-run-header.js.njk" %}
+
+        {% include "src/default/macros/page.js.njk" %}
+
+        {% include "src/default/macros/block-modules.js.njk" %}
+
+        {% if context.next and context.transform.wait==='next' %}
+          flow.waitForNext({
+            key:'{{indexKey}}',
+            next: async () =>  {
+                {% include "src/default/macros/block-next.js.njk" %}
+            }
+          });
+        {% endif %}
+
+        {# NEW: Check if 'new' keyword is present for constructor call #}
+        {% if context.transform.new !== undefined %}
+          {# Constructor instantiation with 'new' keyword #}
+          {% if context.lib.type==='atom' and context.lib.atom.protocol!=='use:' %}
+            const LibClass=LIBRARY;
+          {% elseif context.lib.atom.protocol==='use:' %}
+            {# For use:e:: protocol, call value is the class name (e.g., use:e::Map → Map) #}
+            const LibClass={{context.transform.import}};
+            if(!LibClass) throw new Error('[use] Couldnt find class.');
+          {% else %}
+            throw new Error('Cannot instantiate: unsupported lib type.');
+          {% endif %}
+
+          {# Create instance with constructor args #}
+          {% if context.transform.new %}
+            const constructorArgs = {{ context.transform.new | safe }};
+            const instance = Array.isArray(constructorArgs) ? new LibClass(...constructorArgs) : new LibClass(constructorArgs);
+          {% else %}
+            const instance = new LibClass();
+          {% endif %}
+
+          {# If 'call' is specified, get the method from instance #}
+          {% if context.transform.call %}
+            const callLib = instance.{{context.transform.call}};
+          {% else %}
+            {# No method call, just return the instance #}
+            const callLib = () => instance;
+          {% endif %}
+
+        {% else %}
+          {# EXISTING: Normal function/method call (no 'new') #}
+          {% if context.lib.type==='atom'%}
+            {% if context.transform.libExp %}
+              const lib={{context.transform.libExp}};
+            {% else %}
+              const lib=LIBRARY;
+            {% endif %}
+          {% elseif context.lib.type==='subworkflow' %}
+            const lib={{context.lib.codeKey}};
+          {% elseif target.atom.protocol==='use:' %}
+            const lib={{context.transform.call}};
+            if(!lib) throw new Error('[use] Couldnt find lib.');
+          {% else %}
+            const lib=undefined;
+            throw new Error('Couldn file lib.');
+          {% endif %}
+
+          {% if context.lib.atom.doc.subtype==='workflow'%}
+            const Workflow=lib;
+            const workflow=new Workflow({app:engine.app,caller:c});
+            const callLib = workflow.run.bind(workflow);
+          {% elseif context.lib.type==='subworkflow'%}
+            const Workflow=lib;
+            const workflow=new Workflow({engine,flow,caller:c});
+            const callLib = workflow.run.bind(workflow);
+          {% else %}
+            const callLib = lib;
+          {% endif %}
+        {% endif %}
+
+        {# Execute the call #}
+        {% if context.transform.args %}
+          {% if context.lib.type==='subworkflow' %}
+            const callArgs ={ params: {{ context.transform.args | safe }} };
+          {% else %}
+            const callArgs ={{ context.transform.args | safe }} ;
+          {% endif %}
+
+          {% if context.transform.new !== undefined %}
+            {# For constructor calls, use instance as context #}
+            const result = Array.isArray(callArgs)?  await callLib.apply(instance,callArgs): await callLib.call(instance,callArgs);
+          {% else %}
+            {# For regular calls, use _this as context #}
+            {% if context.transform.context !== undefined %}
+              const result = Array.isArray(callArgs)?  await callLib.apply({{context.transform.context | safe}},callArgs): await callLib.call({{context.transform.context | safe}},callArgs);
+            {% else %}            
+              const result = Array.isArray(callArgs)?  await callLib.apply(_this,callArgs): await callLib.call(_this,callArgs);
+            {% endif %}
+
+          {% endif %}
+
+        {% else %}
+          {% if context.transform.new !== undefined %}
+            const result = await callLib.call(instance);
+          {% else %}
+            {% if context.transform.context !== undefined %}
+              const result = await callLib.call({{context.transform.context | safe}});
+            {% else %}            
+              const result = await callLib.call(_this);
+            {% endif %}
+          {% endif %}
+        {% endif %}
+
+        {% for assign in context.transform.result %}
+          flow.set({{assign.key | safe}},{{assign.value | safe}});
+        {% endfor%}
+
+        {% include "src/default/macros/block-assign.js.njk" %}
+
+        {% include "src/default/macros/block-signal.js.njk" %}
+
+        {% if context.transform.return %}
+          resolve({type:'return',value: {{context.transform.return | safe}}});
+        {% elseif context.next and context.transform.wait!=='next'%}
+          {% include "src/default/macros/block-next.js.njk" %}
+        {% elseif not context.next%}
+          resolve();
+        {% endif %}
+  
+        {% include "src/default/macros/block-run-footer.js.njk" %}
+      }
+      catch(error){
+          onError? onError(error) : reject(error);
+      }      
+    });
+  }
+
+  Object.freeze(this); 
+}
+
+{% include "src/default/macros/block-footer.js.njk" %}

package/template/fnet/node/src/default/blocks/for.js.njk

@@ -0,0 +1,87 @@
+
+{% include "src/default/macros/block-header.js.njk" %}
+
+{% include "src/default/macros/block-next-header.js.njk" %}
+
+{% include "src/default/macros/block-modules-header.js.njk" %}
+
+{% if childs.length %}
+  {% if not childs[0].definition.dynamic %}
+    // FIRST CHILD: {{childs[0].indexKey}}
+    import {{childs[0].codeKey}} from "./{{childs[0].codeKey}}.js";
+  {% endif %}
+{% endif%}
+
+export default function Block(context) {
+
+  {% include "src/default/macros/block-body-header.js.njk" %}
+
+  this.run= function (){
+      
+    {% include "src/default/macros/block-entry-args.js.njk" %}
+
+    return new Promise(async (resolve,reject)=>{
+                  
+      {% include "src/default/macros/block-run-header.js.njk" %}
+      
+      {% include "src/default/macros/page.js.njk" %}
+      
+      {% include "src/default/macros/block-modules.js.njk" %}
+
+      {% if childs.length %}
+        {% if childs[0].definition.dynamic %}
+          // FIRST CHILD: {{childs[0].indexKey}}
+          const { default: {{childs[0].codeKey}} } = await import("./{{childs[0].codeKey}}.js");
+        {% endif %}
+      {% endif%}
+
+      for await(const {{context.transform.for.value | safe}} of {{context.transform.for.in | safe}}){
+        c.for={ {{context.transform.for.value | safe}} };
+
+        {% if childs.length %}
+          let current= new {{childs[0].codeKey}}({ parent:_this, engine, flow, caller:c  });
+          let currentArgs=args;
+
+          do {
+            
+            {% if workflow.parent.context.atom.doc.features.print_runners %}
+              console.log(new Date().toLocaleString(),' * ',_this.constructor.IndexKey,' -> ',current.constructor.IndexKey);
+            {% endif %}
+
+            const nextBlock= typeof currentArgs==='undefined'? await current.run() 
+              : Array.isArray(currentArgs)? await current.run.apply(current,currentArgs) : await current.run.call(current, currentArgs) ;
+
+            if(nextBlock?.type==='return') return resolve(nextBlock);
+            else if(nextBlock?.type!=='block') break;
+
+            if(nextBlock.toType.ParentTypeId!==_this.constructor.TypeId)
+              return resolve(nextBlock);
+
+            current=new nextBlock.toType({ parent:_this, engine, flow, caller:c, onError, error });
+            currentArgs=nextBlock.input;
+            
+          } while(true);
+            
+        {% endif %}
+      }
+
+      {% include "src/default/macros/block-assign.js.njk" %}
+
+      {% include "src/default/macros/block-signal.js.njk" %}
+
+      {% if context.transform.return %}
+        resolve({type:'return',value: {{context.transform.return | safe}}});
+      {% elseif context.next %}
+        {% include "src/default/macros/block-next.js.njk" %}
+      {% else %}
+        resolve();
+      {% endif %}
+
+      {% include "src/default/macros/block-run-footer.js.njk" %}
+    });
+  }    
+
+  Object.freeze(this); 
+}
+
+{% include "src/default/macros/block-footer.js.njk" %}

package/template/fnet/node/src/default/blocks/form.js.njk

@@ -0,0 +1,69 @@
+import React from "react";
+
+{% include "src/default/macros/block-header.js.njk" %}
+
+{% include "src/default/macros/block-next-header.js.njk" %}
+
+{% include "src/default/macros/block-library-header.js.njk" %}
+
+{% include "src/default/macros/block-modules-header.js.njk" %}
+
+export default function Block(context){
+    
+  {% include "src/default/macros/block-body-header.js.njk" %}
+
+  this.run= function (){
+      
+    {% include "src/default/macros/block-entry-args.js.njk" %}
+
+    return new Promise(async (resolve,reject)=>{
+
+
+      try{
+        {% include "src/default/macros/block-run-header.js.njk" %}
+        
+        {% include "src/default/macros/page.js.njk" %}
+
+        {% include "src/default/macros/block-modules.js.njk" %}
+        
+        flow.waitForNext({
+          key:'{{indexKey}}',
+          next: async () => {
+            {% if context.transform.return %}
+              resolve({type:'return',value: {{context.transform.return | safe}}});
+            {% elseif context.next %}
+              {% include "src/default/macros/block-next.js.njk" %}
+            {% else %}
+              resolve();
+            {% endif %}
+          }
+        });
+        
+        {% if context.lib.type==='atom'%}
+          const formLib=LIBRARY;
+        {% elseif context.lib.type==='subworkflow' %}
+          const formLib={{context.lib.codeKey}};
+        {% else %}
+          const formLib=undefined; 
+          throw new Error('Couldnt find form.');
+        {% endif %}
+
+        {% include "src/default/macros/block-run-form.js.njk" %}
+
+        {% include "src/default/macros/block-assign.js.njk" %}
+        
+        {% include "src/default/macros/block-signal.js.njk" %}
+
+        {% include "src/default/macros/block-run-footer.js.njk" %}
+      }
+      catch(error){
+        reject(error);                
+      }
+
+    });
+  } 
+
+  Object.freeze(this);    
+}
+
+{% include "src/default/macros/block-footer.js.njk" %}