@gnar-engine/cli 1.0.0 → 1.0.1

package/bootstrap/services/agent/src/services/agent.service.js

@@ -0,0 +1,259 @@
+import { db, logger, utils } from '@gnar-engine/core';
+import { config } from '../config.js';
+import { chatGptAgent } from '../services/chatgpt.service.js';
+
+export const Agent = {
+
+    client: {},
+
+    /**
+     * Initialise LLM agent
+     *
+     * @returns {string} response
+     */
+    init: async function () {
+        switch (config.agent) {
+            case 'chatgpt':
+                this.client = await chatGptAgent.init() 
+                break;
+        }
+    },
+
+    /**
+     * Plan prompt preparation
+     *
+     * @param {*} inputText
+     * @returns {string} preparedPlanInput
+     */
+    prepareGatherFactsPrompt: function ({inputText, manifests}) {
+        const commandLists = [];
+        const schemaLists = [];
+
+        manifests.manifests.forEach((manifest) => {
+            if (manifest.manifest.commandList?.[0] && manifest.manifest.commandList[0].includes('agentService')) {
+                return;
+            }
+
+            commandLists.push(manifest.manifest.commandList);
+            schemaLists.push(manifest.manifest.schemas);
+        });
+
+        const preparedPlanInput = JSON.stringify({
+            clientPrompt: inputText,
+            systemInstructions: "Respond to the clientPrompt in the format of the responseStructure JSON. Your sole aim is to confirm (using the commandsRequired response property) which commands described in the manifest you will need more information on (command signature), in order to be able to invoke the commands to fulfill the request provided in the clientPrompt. Simillarly, please ensure that you request all required information as per the schema manifest from the user in the responseText. If there aren't suitable commands, explain that you can't with no further options. If it is not yet clear, please request clarification. The responseText will be shown to the customer so ensure that responses are non-technical and don't go into detail about the rest of the response.",
+            responseStructure: {
+                responseText: "Customer facing message reply here",
+                commandsRequired: [
+                    'e.g. userService.create',
+                    'userService.update'
+                ]
+            },
+            commandManifest: commandLists,
+            schemaManifest: schemaLists
+        });
+
+        logger.info(preparedPlanInput);
+
+        return preparedPlanInput;
+    },
+
+    /**
+     * Plan prompt preparation
+     *
+     * @param {*} inputText
+     * @returns {string} preparedPlanInput
+     */
+    preparePlanPrompt: function ({inputText, manifests}) {
+        const commandLists = [];
+        const schemaLists = [];
+
+        manifests.manifests.forEach((manifest) => {
+            if (manifest.manifest.commandList?.[0] && manifest.manifest.commandList[0].includes('agentService')) {
+                return;
+            }
+
+            commandLists.push(manifest.manifest.commandList);
+            schemaLists.push(manifest.manifest.schema);
+        });
+
+        const preparedPlanInput = JSON.stringify({
+            clientPrompt: inputText,
+            systemInstructions: "Respond to the clientPrompt in the format of the responseStructure JSON. Your sole aim is to confirm using the commandsRequired response property, which commands described in the manifest you will need more information, in order to be able to invoke the commands to fulfill the request provided in the clientPrompt. If there aren't suitable commands, explain that you can't with no further options. If it is not yet clear, please request clarification. The responseText will be shown to the customer so ensure that responses are non-technical and don't go into detail about the rest of the response.",
+            responseStructure: {
+                responseText: "Customer facing message reply here",
+                actionPlan: [
+                    {
+                        planDesc: "Fetch the user ID using the email address provided",
+                        commandName: "userService.getSingle"
+                    },
+                    {
+                        planDesc: "update the users first name as requested",
+                        commandName: "userService.update"
+                    }
+                ],
+                commandsRequired: [
+                    'e.g. userService.create',
+                    'userService.update'
+                ]
+            },
+            commandManifest: commandLists,
+            schemaManifest: schemaLists
+        });
+
+        logger.info(preparedPlanInput);
+
+        return preparedPlanInput;
+    },
+
+
+    /**
+     * Action plan step prompt preparation
+     *
+     * @param {*} inputText
+     * @returns {string} preparedActionPlanStepPrompt
+     */
+    preparedActionPlanStepPrompt: function ({actionPlanStepDesc, manifest}) {
+
+    },
+
+    /**
+     * Prompt augmentation for the agent
+     * 
+     * @param {*} inputText 
+     * @returns {string} preparedInput
+     */
+    preparePrompt: function ({inputText}) {
+        const preparedInput = JSON.stringify({
+            clientPrompt: inputText,
+            systemInstructions: "Respond to the clientPrompt in the the format of the responseStructure JSON. If there is an appropriate flow of actions to take based on the actions described in the registeredServices you should respond with a command otherwise don't. You should always include a customer facing message requesting clarifications or the action taken.",
+            responseStructure: {
+                responseText: "Your message here",
+                action: {
+                    commandName: "e.g. userService.update",
+                    payload: {
+                        userId: "12345",
+                        data: {}
+                    }
+                }
+            },
+            registeredServices: [
+                {
+                    serviceName: "userService",
+                    actions: [
+                        {
+                            name: "update",
+                            description: "Update user information",
+                            parameters: {
+                                userId: "string",
+                                data: "object"
+                            }
+                        }
+                    ]
+                }
+            ]
+        })
+
+        return preparedInput;
+    },
+
+    /**
+     * Create a new chat session
+     * 
+     * @param {string} userId 
+     * @param {string} title 
+     * @param {string} sessionKey
+     * @returns {string} chatId
+     */
+    createChat: async function ({userId, title, sessionKey}) {
+        const chatId = utils.uuid();
+
+        await db.query(
+            'INSERT INTO agent_chats (id, user_id, title) VALUES (?, ?, ?)',
+            [chatId, userId, title]
+        );
+
+        return chatId;
+    },
+
+    /**
+     * Get a chat (with all messages) 
+     *
+     * @param {string} chatId
+     * @returns {object} chat
+     */
+    getChat: async function ({chatId}) {
+        try {
+            // Fetch the chat
+            const chatResult = await db.query(
+                'SELECT * FROM agent_chats WHERE id = ?',
+                [chatId]
+            );
+
+            if (!chatResult || chatResult.length === 0) {
+                throw new Error(`Chat with ID ${chatId} not found`);
+            }
+
+            const chat = chatResult[0][0];
+
+            // Fetch messages for the chat
+            const chatMessageResult = await db.query(
+                'SELECT id, chat_id, user_name, context, created_at FROM agent_chat_messages WHERE chat_id = ? ORDER BY created_at ASC',
+                [chatId]
+            );
+
+            if (!chatMessageResult || chatMessageResult.length === 0) {
+                throw new Error('No chat messages found');
+            }
+
+            chat.messages = chatMessageResult[0];
+
+            return chat;
+        } catch (err) {
+            logger.error(`Error fetching chat ${chatId}: ${err.message}`);
+            throw err;
+        }
+    },
+
+    /**
+     * Create a new chat message
+     * 
+     * @param {string} chatId
+     * @param {string} userName
+     * @param {object} context
+     */
+    createChatMessage: async function ({chatId, userName, context}) {
+        try {
+            const messageId = utils.uuid();
+            context = JSON.stringify(context);
+
+            logger.info('storing context: ' + context);
+
+            await db.query(
+                'INSERT INTO agent_chat_messages (id, chat_id, user_name, context) VALUES (?, ?, ?, ?)',
+                [messageId, chatId, userName, context]
+            );
+        } catch (err) {
+            logger.error('Error creating chat message: ' + err.message);
+        }
+    },
+
+    /**
+     * Infer LLM agent
+     *
+     * @param {string} preparedInput
+     * @returns {string} response
+     */
+    infer: async function ({preparedInput}) {
+
+        let response;
+        
+        switch (config.agent) {
+            case 'chatgpt':
+                response = await chatGptAgent.getResponse(preparedInput) 
+                break;
+        }
+
+        return response;
+    }
+
+};

package/bootstrap/services/agent/src/services/chatgpt.service.js

@@ -0,0 +1,46 @@
+import OpenAI from "openai";
+import { logger } from "@gnar-engine/core";
+
+
+export const chatGptAgent = {
+
+    client: null,
+
+    init: function () {
+        if (this.client) {
+            return this.client;
+        }
+
+        return this.client = new OpenAI({
+            apiKey: process.env.OPENAI_API_KEY,
+            baseURL: process.env.OPENAI_API_BASE_URL || 'https://api.openai.com/v1',
+        });
+    },
+
+    getResponse: async function (preparedInput) {
+        try {
+            logger.info('LLM request sending...');
+            const response = await this.client.chat.completions.create({
+                model: "gpt-5-mini",
+                messages: [
+                    {
+                        role: "user",
+                        content: [
+                            {
+                                type: "text",
+                                text: preparedInput
+                            }
+                        ],
+                    },
+                ],
+            });
+
+            logger.info('LLM response returned');
+
+            return response.choices[0].message.content;
+        } catch (error) {
+            logger.error("ChatGPT agent error:" + error);
+            throw error;
+        }
+    }
+}

package/bootstrap/services/agent/src/services/manifest.service.js

@@ -0,0 +1,21 @@
+import { commands, logger } from '@gnar-engine/core';
+
+
+export const manifestService = {
+
+    commandList: {},
+    schemaList: {},
+
+    /**
+     * Generate service manifests
+     */
+    generateServiceManifests: async () => {
+        logger.info('Generating command manifest...');
+
+        // Get services from control service
+        const manifests = await commands.execute('controlService.getManifests'); 
+
+        
+    }
+
+}

package/bootstrap/services/control/Dockerfile

@@ -0,0 +1,23 @@
+# Dockerfile for Control Service
+FROM node:20-alpine
+
+# Set the working directory
+WORKDIR /usr/gnar_engine/app
+
+# Define a global env var
+ENV GLOBAL_SERVICE_BASE_DIR=/usr/gnar_engine/app/src/
+
+# Copy package.json and package-lock.json
+COPY ./services/control/package*.json ./
+
+# Install nodemon
+RUN npm install -g nodemon
+
+# Install app dependencies
+RUN npm install
+
+# Expose the port the service will run on
+EXPOSE 3000
+
+# Start the application
+CMD ["nodemon", "--watch", "./gnar_engine", "./gnar_engine/app.js"]

package/bootstrap/services/control/Dockerfile.prod

@@ -0,0 +1,37 @@
+# Stage 1: Builder
+FROM node:20-alpine AS builder
+
+WORKDIR /app
+
+# Copy app source
+COPY ./services/control/src ./src
+COPY ./Lib ./Lib
+
+# Copy environment variables (do this later in build only if needed)
+COPY ./.env.production .env
+
+# Copy package files and install deps
+COPY ./services/control/package*.json ./
+RUN npm install --omit=dev
+
+# Stage 2: Runtime
+FROM node:20-alpine
+
+WORKDIR /app
+
+# Copy built app from builder stage
+COPY --from=builder /app /app
+
+# Install system deps
+RUN apk add --no-cache ca-certificates wget
+
+# Install AWS DocumentDB CA certificates
+RUN mkdir -p /usr/local/share/ca-certificates && \
+    wget https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem -O /usr/local/share/ca-certificates/aws-docdb.pem && \
+    update-ca-certificates
+
+# Expose port
+EXPOSE 4000
+
+# Start app
+CMD ["npm", "run", "start"]

package/bootstrap/services/control/README.md

@@ -0,0 +1,25 @@
+# Gnar Engine Control Service
+
+- Used for scheduling and running tasks
+- Used for service registry
+- Used by the CLI
+
+### Commands
+
+Start dev server           npm start:dev
+Start production server    npm start
+Run tests                  npm test
+
+### notes
+
+Cron job runs:
+
+Fetch due tasks from SQL (status = pending).
+Push them to RabbitMQ.
+Update the database status to queued.
+Worker service processes tasks:
+
+Listens for tasks in RabbitMQ.
+Executes the task (e.g., calling another microservice).
+On success, updates SQL status to completed.
+On failure, updates SQL status to failed and may retry.

package/bootstrap/services/control/package.json

@@ -0,0 +1,16 @@
+{
+    "name": "gnar_engine_control",
+    "version": "1.0.0",
+    "description": "Gnar Engine - Control Service",
+    "type": "module",
+    "scripts": {
+        "start": "node ./src/app.js",
+        "start:dev": "nodemon --watch ./src ./src/app.js",
+        "test": "jest --watchAll --verbose"
+    },
+    "author": "Gnar Software Ltd",
+    "license": "ISC",
+    "dependencies": {
+        "@gnar-engine/core": "^1.0.1"
+    }
+}

package/bootstrap/services/control/src/app.js

@@ -0,0 +1,45 @@
+import { message, http, logger, db, registerService, webSockets } from '@gnar-engine/core';
+import { config } from './config.js';
+import { messageHandlers } from './controllers/message.controller.js';
+import { httpController as controlPlatformHttpController } from './controllers/http.controller.js';
+
+
+/**
+ * Initialise service
+ */
+export const initService = async () => {
+
+    // Run migrations
+    db.migrations.runMigrations({config});
+
+    // Import command handlers after the command bus is initialised
+    await import('./commands/control.handler.js');
+    await import('./commands/service.handler.js');
+    await import('./commands/task.handler.js');
+
+    // Initialise and register message handlers
+    await message.init({
+        config: config.message,
+        handlers: messageHandlers
+    });
+
+    // Initialise websocket client & server
+    await webSockets.init(config.webSockets, config.serviceName);
+
+    // Register http routes
+    await http.registerRoutes({
+        controllers: [
+            controlPlatformHttpController,
+        ]
+    });
+
+    // Start the HTTP server
+    await http.start();
+
+    // Register service with control service
+    await registerService();
+
+    logger.info('G n a r  E n g i n e | Control Service initialised successfully.');
+}
+
+initService();