@kumologica/sdk 3.4.0 → 3.5.0-beta2

package/cli/commands/create-commands/openapi.js

@@ -0,0 +1,42 @@
+const pathlib = require('path');
+const { prompt, Select } = require('enquirer');
+const { logNotice, logError } = require('../../utils/logger');
+const { downloadTemplateFromRepo, listAvailableTemplates } = require('../../utils/download-template-from-repo');
+
+async function createProjectIteratively(){
+    const availableTemplates = await listAvailableTemplates();
+    // Project name
+    const projectNameResponse = await prompt({
+        type: 'input',
+        name: 'projectName',
+        message: 'Enter the name for the project'
+    });
+    let aProjectName = projectNameResponse.projectName;
+
+    // Target Path
+    const directoryResponse = await prompt({
+        type: 'input',
+        name: 'directory',
+        message: 'Enter the path where the project will be created '
+    });
+    let aProjectPath = directoryResponse.directory;
+
+    // Template name
+    const promptTemplate = new Select({
+        name: 'template',
+        message: 'Pick one of the available templates',
+        choices: availableTemplates
+      });
+
+    let aTemplateName = await promptTemplate.run();
+
+    try{
+        await downloadTemplateFromRepo(undefined, aTemplateName, aProjectPath, aProjectName);
+        logNotice(`Successfully created project: ${pathlib.join(aProjectPath, aProjectName)}`)
+    } catch (err){
+        logError(`Error found while creating project due to: ${err.message}`)
+    }
+}
+    
+
+module.exports = createProjectIteratively;

package/cli/commands/create.js

@@ -20,32 +20,41 @@ exports.builder = (yargs) => {
         alias: 't',
         nargs: 1
     })
+    yargs.option(`api`, {
+        describe: `OpenApi/Swagger definition of the api`,
+        type: 'string',
+        alias: 'a',
+        nargs: 1
+    })
 }
 
 
 exports.desc = 'Create a kumologica project. Do not pass any options to create iteratively.'
-exports.handler = async ({ path, template }) => {
+exports.handler = async ({ path, template, api }) => {
     const { version } = require('../../package.json');
 
-    if (!path && !template) {
+    if (!path && !template && !api) {
         await createProjectIteratively();
+        
     } else if (!path && template) {
-        try{
+        try {
             await downloadTemplateFromRepo(undefined, template, process.cwd(), template);
-            logNotice(`Successfully created project: ${ pathlib.join(process.cwd(), template)}`);
-        }catch(e){
+            logNotice(`Successfully created project: ${ pathlib.join(process.cwd(), template)}`);  
+        } catch(e) {
             logError(e.message);
         }
+
     } else if (path && !template){
-        try{
+        try {
             codegen.generateBoilerplateProject({ 
                 basePath :process.cwd(), 
                 projectName: path,
                 runtimeVersion: version });
             logNotice(`Successfully created project: ${ pathlib.join(process.cwd(), path)}`);
-        }catch(e){
+        } catch(e) {
             logError(e.message);
         }
+
     } else if (path && template) {
         path = pathlib.resolve(path);
         let projectPath = pathlib.dirname(path);
@@ -57,7 +66,7 @@ exports.handler = async ({ path, template }) => {
                 await downloadTemplateFromRepo(undefined, template, projectPath, projectName);
             }
             logNotice(`Successfully created project: ${path}`);
-        }catch(e){
+        } catch(e) {
             logError(e.message);
         }
     }

package/cli/commands/login.js

@@ -0,0 +1,87 @@
+
+const { prompt, Select } = require('enquirer');
+
+exports.command = 'login';
+exports.desc = `Login to kumologica.dev`;
+
+exports.builder = {		
+		
+	"email": {
+		describe: "Valid email address for login",
+		type: 'string',
+        alias: 'e',
+		nargs: 1
+	},
+	"password": {
+		describe: "Password for login.",
+		type: 'string',
+        alias: 'p',
+		nargs: 1
+	}
+}
+	
+async function login(email, password) {
+    const { CognitoIdentityProviderClient, InitiateAuthCommand } = require("@aws-sdk/client-cognito-identity-provider"); 
+    const client = new CognitoIdentityProviderClient();
+
+    const input = {
+        AuthFlow: "USER_PASSWORD_AUTH",
+        AuthParameters: {
+          PASSWORD: password,
+          USERNAME: email
+        },
+        ClientId: "5qm756mn3otap8o8f2vf6vqj96"
+      };
+      const command = new InitiateAuthCommand(input);
+      const response = await client.send(command);
+      console.log(JSON.stringify(response, null, 2));
+
+
+};
+
+
+exports.handler =  async function (argv) {
+	
+	const chalk = require('chalk');
+
+	try {
+		let email;
+
+        if (argv.email) {
+            email = argv.email;
+        } else {
+            const emailPrompt = await prompt({
+                type: 'input',
+                name: 'email',
+                message: 'Enter valid email address to be used for login'
+            });
+            email = emailPrompt.email;
+        }
+
+        console.log(`\Logging in to komologica.dev using email: ${email}\n`);
+
+		let pwd;
+
+        if (argv.password) {
+            pwd = argv.password;
+        } else { 
+            const pwdPrompt = await prompt({
+                type: 'input',
+                name: 'password',
+                message: 'Enter password.'
+            });
+            pwd = pwdPrompt.password;
+        }
+        
+        await login(email, pwd);
+
+        
+		console.log(chalk.greenBright('Login successful.'));
+	
+		process.exit(0);
+	} catch (e) {
+
+		console.log(`${chalk.redBright(e.message)}`);
+		process.exit(1);
+	}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kumologica/sdk",
-  "version": "3.4.0",
+  "version": "3.5.0-beta2",
   "productName": "Kumologica Designer",
   "copyright": "Copyright 2020 Kumologica Pty Ltd, All Rights Reserved.",
   "author": "Kumologica Pty Ltd <contact@kumologica.com>",
@@ -63,14 +63,24 @@
   },
   "license": "Proprietary",
   "dependencies": {
+    "@aws-sdk/client-api-gateway": "^3.556.0",
+    "@aws-sdk/client-cloudformation": "^3.556.0",
+    "@aws-sdk/client-cloudwatch-events": "^3.556.0",
+    "@aws-sdk/client-dynamodb-streams": "^3.556.0",
+    "@aws-sdk/client-elastic-load-balancing-v2": "^3.556.0",
+    "@aws-sdk/client-iam": "^3.556.0",
+    "@aws-sdk/client-iot": "^3.556.0",
+    "@aws-sdk/client-s3": "^3.556.0",
+    "@aws-sdk/client-sns": "^3.556.0",
+    "@aws-sdk/client-sqs": "^3.556.0",
+    "@aws-sdk/credential-providers": "^3.556.0",
     "@electron/remote": "^2.0.8",
-    "@kumologica/builder": "3.4.0",
-    "@kumologica/devkit": "3.4.0",
-    "@kumologica/runtime": "3.4.0",
+    "@kumologica/builder": "3.5.0-beta2",
+    "@kumologica/devkit": "3.5.0-beta2",
+    "@kumologica/runtime": "3.5.0-beta2",
     "adm-zip": "0.4.13",
     "ajv": "8.10.0",
     "archive-type": "^4.0.0",
-    "aws-sdk": "2.513.0",
     "basic-auth": "2.0.1",
     "bcryptjs": "2.4.3",
     "bluebird": "^3.7.2",
@@ -111,6 +121,7 @@
     "mime": "2.4.4",
     "mustache": "3.0.1",
     "oauth2orize": "1.11.0",
+    "openai": "^4.28.4",
     "os": "0.1.1",
     "p-event": "^5.0.1",
     "passport": "0.4.0",
@@ -164,9 +175,9 @@
     "typescript": "^3.5.3"
   },
   "engines": {
-    "node": ">=8"
+    "node": ">=18"
   },
   "kumologica": {
-    "dev": false
+    "dev": true
   }
 }

package/src/app/lib/ai/layout.js

@@ -0,0 +1,75 @@
+const dagre = require('dagre');
+
+const NODE_SIZE = 45;
+const NODE_SEP = 50;
+const MARGIN_X = 50;
+const MARGIN_Y = 50;
+
+function applyLayout(nodes) {
+    let layarizedFlow = [];
+
+    let tabs = nodes.filter(n => n.type === 'tab');
+    // No tab, most likely a single nod
+    if (tabs.length === 0) {
+        let tabIds = [...new Set(nodes.map(item => item.z))];
+        tabIds.map(tabId => {
+            layarizedFlow.push(...applyTabLayout(nodes, tabId));
+        })
+    } else {
+        tabs.map(tab => {
+            layarizedFlow.push(tab);
+            layarizedFlow.push(...applyTabLayout(nodes, tab.id));
+        })
+    }
+
+    return layarizedFlow;
+}
+
+function applyTabLayout(nodes, tabId) {
+    let nodesOnTab = nodes.filter(n => n.z === tabId) || [];
+
+    // Prepare the graph
+    let g = new dagre.graphlib.Graph();
+
+    // Set an object for the graph label
+    g.setGraph({
+        rankdir: "LR",
+        nodesep: NODE_SEP,
+        marginx: MARGIN_X,
+        marginy: MARGIN_Y
+    });
+
+    // Default to assigning a new object as a label for each new edge.
+    g.setDefaultEdgeLabel(function () { return {}; });
+
+    // Create nodes for the graph
+    nodesOnTab.forEach(n => {
+        g.setNode(n.id, { label: n.name, width: NODE_SIZE, height: NODE_SIZE })
+
+        // TODO - Check the wires here and create the edge
+        if (n.wires && Array.isArray(n.wires) && n.wires.length > 0) {
+            n.wires.forEach(wire => {
+                g.setEdge(n.id, wire)
+            })
+        }
+    });
+
+    dagre.layout(g);
+
+    // Apply the coordinates
+    g.nodes().forEach(nid => {
+        if (nid) {
+            let node = nodesOnTab.find(n => n.id === nid);
+            if (node) {
+                node.x = g.node(nid).x;
+                node.y = Number.isNaN(g.node(nid).y) ? 0 : g.node(nid).y;
+            }
+        }
+    });
+
+    return nodesOnTab;
+}
+
+module.exports = {
+    applyLayout
+}

package/src/app/lib/ai/openai.js

@@ -0,0 +1,108 @@
+const OpenAI = require('openai');
+const fs = require('fs');
+const path = require('path');
+const { applyLayout } = require('./layout');
+
+
+require('dotenv').config()
+
+// utils
+function unescapeObject(obj) {
+    // Check if the input is an object
+    if (typeof obj !== 'object' || obj === null) {
+        return obj; // Return as is if not an object
+    }
+
+    // Iterate over each property of the object
+    for (let key in obj) {
+        if (obj.hasOwnProperty(key)) {
+            // If the property is a string, unescape it
+            if (typeof obj[key] === 'string') {
+                obj[key] = unescapeString(obj[key]);
+            }
+            // If the property is an object, recursively unescape its properties
+            else if (typeof obj[key] === 'object') {
+                obj[key] = unescapeObject(obj[key]);
+            }
+        }
+    }
+
+    return obj;
+}
+
+// Function to unescape a string
+function unescapeString(str) {
+    // Remove all occurrences of  "\n 
+    str = str.replace(/\\n\s*|\\n/g, '');
+
+
+    return str.replace(/\\(.)/g, function (_, char) {
+        switch (char) {
+            case 'n': return '\n'; // Replace '\n' with newline character
+            case 't': return '\t'; // Replace '\t' with tab character
+            case 'r': return '\r'; // Replace '\r' with carriage return character
+            case 'b': return '\b'; // Replace '\b' with backspace character
+            case 'f': return '\f'; // Replace '\f' with form feed character
+            case '\\': return '\\'; // Replace '\\' with backslash character
+            case '"': return '"';   // Replace '\"' with double quote character
+            case "'": return "'";   // Replace "\'" with single quote character
+            default: return char;  // Return the character as is if not an escape sequence
+        }
+    });
+}
+
+
+class OpenAIClient {
+    // attributes
+    openai = null;
+    version = null;
+
+    constructor(props) {
+        this.openai = new OpenAI({
+            apiKey: props.key || process.env.OPENAI_API_KEY || '***',
+            dangerouslyAllowBrowser: true
+        });
+        this.version = props.version || 'gpt-3.5-turbo';
+    }
+
+    getSystemPrompt() {
+        if (!this.systemPrompt) {
+            try {
+                this.systemPrompt = fs.readFileSync(path.join(__dirname, 'prompt.txt'), 'utf-8');
+            } catch (err) {
+                throw err;
+            }
+        }
+        return this.systemPrompt;
+    }
+
+    async t2c(userTask) {
+        let userMessage = `
+        Generate kumologica flow. Do not include any extra explanation, just the json document. For the following user description:
+        ${userTask}`;
+        try {
+            let spec = this.getSystemPrompt();
+            const chatCompletion = await this.openai.chat.completions.create({
+                model: this.version,
+                messages: [
+                    { role: 'system', content: spec },
+                    { role: 'user', content: userMessage }
+                ]
+            });
+
+            const resp = chatCompletion.choices[0].message.content;
+            console.log('[openai] Resp=', resp);
+            const respo = JSON.parse(resp);
+            console.log('[openai] Resp.flow=', JSON.parse(respo.flow));
+            console.log('[openai] Unscaped - Resp.flow', unescapeObject(JSON.parse(respo.flow)));
+            return applyLayout(unescapeObject(JSON.parse(respo.flow)));
+        } catch (err) {
+            console.log(err);
+            throw new Error(err.toString());
+        }
+    }
+}
+
+module.exports = {
+    OpenAIClient
+}