@solidxai/core 0.0.2

package/src/seeders/sms-template-seeder.service.ts

@@ -0,0 +1,50 @@
+import { Inject, Injectable, Logger } from '@nestjs/common';
+import * as fs from 'fs';
+import * as path from 'path';
+import type { SolidCoreSetting } from "src/services/settings/default-settings-provider.service";
+
+import { ConfigType } from '@nestjs/config';
+import { CreateSmsTemplateDto } from '../dtos/create-sms-template.dto';
+import { SmsTemplateService } from '../services/sms-template.service';
+import { SettingService } from 'src/services/setting.service';
+
+@Injectable()
+export class SmsTemplateSeederService {
+    private readonly logger = new Logger(SmsTemplateSeederService.name);
+
+    constructor(
+        private readonly smsTemplateService: SmsTemplateService,
+        private readonly settingService: SettingService
+    ) { }
+
+    async seed() {
+        // Read the module metadata from a file specified in the .env 
+        const seedDataFileVariable = this.settingService.getConfigValue<SolidCoreSetting>("smsTemplateSeederFiles");
+        const seedDataFiles = seedDataFileVariable.split(',');
+
+        for (let i = 0; i < seedDataFiles.length; i++) {
+            const seedDataFile = seedDataFiles[i];
+            const fullPath = path.join(process.cwd(), seedDataFile);
+
+            // For each module metadata seed file provided, read contents, parse & convert to a variable. 
+            this.logger.log(`Using sms template seed data: ${fullPath}`);
+            const smsTemplateJson = fs.readFileSync(fullPath, 'utf-8').toString();
+            const smsTemplates: CreateSmsTemplateDto[] = JSON.parse(smsTemplateJson);
+
+            for (let i = 0; i < smsTemplates.length; i++) {
+                const smsTemplate = smsTemplates[i];
+                this.logger.log(`Found ${smsTemplate.name} sms template`);
+
+                // We need to load the actual template contents. 
+                if (smsTemplate.body) {
+                    const smsTemplateFilePath = path.join(process.cwd(), smsTemplate.body);
+                    smsTemplate.body = fs.readFileSync(smsTemplateFilePath, 'utf-8').toString()
+                }
+
+                // Save to DB.
+                await this.smsTemplateService.removeByName(smsTemplate.name);
+                await this.smsTemplateService.create(smsTemplate);
+            }
+        }
+    }
+}

package/src/seeders/system-fields-seeder.service.ts

@@ -0,0 +1,60 @@
+// This class will add the system fields in the field-metadata table if they are missing.
+// Fetch all the models and their fields metadata and check if the system fields are present.
+
+import { forwardRef, Inject, Injectable, Logger } from "@nestjs/common";
+import { ModelMetadata } from "src/entities/model-metadata.entity";
+import { ModelMetadataHelperService } from "src/helpers/model-metadata-helper.service";
+import { FieldMetadataRepository } from "src/repository/field-metadata.repository";
+import { ModelMetadataRepository } from "src/repository/model-metadata.repository";
+
+@Injectable()
+export class SystemFieldsSeederService {
+  private readonly logger = new Logger(SystemFieldsSeederService.name);
+  // This service is responsible for seeding the system fields metadata for all models.
+  // It will check if the system fields are already present in the field-metadata table.
+  // If not, it will add them.
+  constructor(
+    private readonly modelHelperService: ModelMetadataHelperService,
+    //   @InjectRepository(ModelMetadata)
+    //   private readonly modelRepository: Repository<ModelMetadata>, // Replace with actual model repository type
+    @Inject(forwardRef(() => ModelMetadataRepository))
+    private readonly modelRepository: ModelMetadataRepository, // Replace with actual model repository type
+    private readonly fieldMetadataRepository: FieldMetadataRepository, // Replace with actual field repository type
+  ) { }
+
+  async seed() {
+    // Get the model repo
+    const models = await this.modelRepository.find({
+      relations: ['fields'], // Assuming 'fields' is the relation to field metadata
+    });
+
+    for (const model of models) {
+      // Check if the system fields are already present
+      await this.seedMissingSystemFields(model);
+    }
+  }
+
+  private async seedMissingSystemFields(model: ModelMetadata) {
+    this.logger.debug(`Checking system fields for model: ${model.singularName}`);
+    const existingSystemFields = model.fields.filter(field => field.isSystem);
+    const systemFieldsMetadata = this.modelHelperService.getSystemFieldsMetadata(model.isLegacyTable, model.isLegacyTableWithId);
+    this.logger.debug(`Model: ${model.singularName} has ${existingSystemFields.length} existing system fields.`);
+    // Find out which system fields are missing
+    const missingFields = systemFieldsMetadata.filter(
+      sysField => !existingSystemFields.some(field => field.name === sysField.name)
+    );
+
+    // If there are missing fields, add them
+    if (missingFields.length > 0) {
+      this.logger.debug(`Seeding ${missingFields.length} missing system fields for model: ${model.singularName}`);
+      const newFields = missingFields.map(field => ({
+        ...field,
+        model: model, // Associate the field with the current model
+      }));
+      await this.fieldMetadataRepository.save(newFields);
+    }
+    else {
+      this.logger.debug(`No missing system fields for model: ${model.singularName}`);
+    }
+  }
+}

package/src/seeders/user-seeder.service.ts

@@ -0,0 +1,33 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { AuthenticationService } from '../services/authentication.service';
+import { UserService } from '../services/user.service';
+import { v4 as uuidv4 } from 'uuid';
+
+@Injectable()
+export class UserSeederService {
+    private readonly logger = new Logger(UserSeederService.name);
+
+    constructor(
+        private readonly authenticationService: AuthenticationService,
+        private readonly userService: UserService,
+    ) { }
+
+    async seed() {
+        // see if the user already exists, 
+        let user = await this.userService.findOneByUsername("sa");
+
+        if (!user) {
+            user = await this.authenticationService.signUp({
+                username: 'sa',
+                email: 'sa@solidxai.com',
+                password: uuidv4(),
+            });    
+
+            this.logger.log(`Newly created user is ${user}`);
+        }
+
+        // now make this user an Admin by adding them to the Admin role group. 
+        await this.userService.addRoleToUser(user.email, "Admin");
+        await this.userService.addRoleToUser(user.email, "Public");
+    }
+}

package/src/services/1.js

@@ -0,0 +1,6 @@
+1. Do i need to create a storeStreams method for aws service too?
+    - Handle later
+2. queues handling -> if queues is enabled by default, i.e triggerExport(exportTransactionEntity.id).
+    - startExport should either return the data or return the transaction id
+3. How to handle scenarios wherein, nested related exist.(do i need to only get the userkey)
+    - show the userKey

package/src/services/action-metadata.service.ts

@@ -0,0 +1,55 @@
+import { Injectable } from '@nestjs/common';
+import { ModuleRef } from "@nestjs/core";
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { CRUDService } from 'src/services/crud.service';
+import { EntityManager } from 'typeorm';
+
+
+import { ActionMetadataRepository } from 'src/repository/action-metadata.repository';
+import { ActionMetadata } from '../entities/action-metadata.entity';
+
+@Injectable()
+export class ActionMetadataService extends CRUDService<ActionMetadata> {
+  constructor(
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    // @InjectRepository(ActionMetadata, 'default')
+    // readonly repo: Repository<ActionMetadata>,
+    readonly repo: ActionMetadataRepository,
+    readonly moduleRef: ModuleRef
+
+  ) {
+    super(entityManager, repo, 'actionMetadata', 'solid-core', moduleRef);
+  }
+
+  async findOneByUserKey(name: string, relations = {}) {
+    const entity = await this.repo.findOne({
+      where: {
+        name: name,
+      },
+      relations: relations,
+    });
+    return entity;
+  }
+
+  async upsert(updateSolidActionDto: any) {
+    // First check if module already exists using name
+    const existingSolidAction = await this.repo.findOne({
+      where: {
+        name: updateSolidActionDto.name
+      }
+    })
+
+    // if found
+    if (existingSolidAction) {
+      const updatedSolidActionDto = { ...existingSolidAction, ...updateSolidActionDto };
+      return this.repo.save(updatedSolidActionDto);
+    }
+    // if not found - create new 
+    else {
+      const moduleMetadata = this.repo.create(updateSolidActionDto);
+      return this.repo.save(moduleMetadata);
+    }
+  }
+
+}

package/src/services/ai-interaction.service.ts

@@ -0,0 +1,239 @@
+import { BadRequestException, Injectable, Logger } from '@nestjs/common';
+import { ModuleRef } from "@nestjs/core";
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { EntityManager } from 'typeorm';
+import type { SolidCoreSetting } from "src/services/settings/default-settings-provider.service";
+
+import { spawn } from 'child_process';
+import * as fs from 'fs/promises';
+import { ERROR_MESSAGES } from 'src/constants/error-messages';
+import { InvokeAiPromptDto } from 'src/dtos/invoke-ai-prompt.dto';
+import { McpResponse, TriggerMcpClientOptions } from 'src/interfaces';
+import { AiInteractionRepository } from 'src/repository/ai-interaction.repository';
+import { CRUDService } from 'src/services/crud.service';
+import { AiInteraction } from '../entities/ai-interaction.entity';
+import { McpHandlerFactory } from './genai/mcp-handlers/mcp-handler-factory.service';
+import { PublisherFactory } from './queues/publisher-factory.service';
+
+@Injectable()
+export class AiInteractionService extends CRUDService<AiInteraction> {
+  private readonly logger = new Logger(AiInteractionService.name);
+
+  constructor(
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    // @InjectRepository(AiInteraction, 'default')
+    // readonly repo: Repository<AiInteraction>,
+    readonly repo: AiInteractionRepository,
+    readonly moduleRef: ModuleRef,
+    readonly publisherFactory: PublisherFactory<TriggerMcpClientOptions>,
+    // readonly requestContextService: RequestContextService,
+    readonly mcpHandlerFactory: McpHandlerFactory,
+
+  ) {
+    super(entityManager, repo, 'aiInteraction', 'solid-core', moduleRef);
+  }
+
+  async triggerMcpClientJob(dto: InvokeAiPromptDto, userId: number, isAutoApply: boolean = false, threadId: string = null): Promise<any> {
+    // const activeUser: ActiveUserData = this.requestContextService.getActiveUser();
+
+    const aiInteraction = await this.create({
+      userId: userId,
+      threadId: threadId ? threadId : `thread-${userId}`,
+      role: 'human',
+      message: dto.prompt,
+      contentType: '',
+      errorMessage: '',
+      modelUsed: '',
+      responseTimeMs: 0,
+      metadata: '',
+      isAutoApply: isAutoApply
+    });
+    const m = {
+      payload: {
+        aiInteractionId: aiInteraction.id,
+        moduleName: dto.moduleName
+      },
+      parentEntity: 'aiInteraction',
+      parentEntityId: aiInteraction.id,
+    };
+
+    const queueMessageId = await this.publisherFactory.publish(m, 'TriggerMcpClientPublisher');
+
+    return {
+      queueMessageId: queueMessageId,
+      aiInteractionId: aiInteraction.id
+    }
+  }
+
+  /**
+   * Runs the Python MCP client with a prompt and returns the parsed JSON embedded in the 'response'.
+   * @param prompt - The question or instruction to send to the MCP client.
+   * @returns The parsed object inside the 'response' field of the JSON output.
+   */
+  async runMcpPrompt(prompt: string): Promise<McpResponse> {
+    const pythonExecutable = this.settingService.getConfigValue<SolidCoreSetting>('mcpPythonExecutable');
+    const mcpClient = this.settingService.getConfigValue<SolidCoreSetting>('mcpClient');
+
+    // TODO: We can return an error if the above env variables are not properly setup...
+    if (!pythonExecutable || !mcpClient) {
+      throw new BadRequestException(ERROR_MESSAGES.PYTHON_EXECUTABLE_NOT_CONFIGURED);
+    }
+
+    // Check if both paths are valid and accessible
+    try {
+      const [pyStat, clientStat] = await Promise.all([
+        fs.stat(pythonExecutable),
+        fs.stat(mcpClient),
+      ]);
+
+      if (!pyStat.isFile()) {
+        throw new BadRequestException(`MCP_PYTHON_EXECUTABLE path is not a file: ${pythonExecutable}`);
+      }
+
+      if (!clientStat.isFile()) {
+        throw new BadRequestException(`MCP_CLIENT path is not a file: ${mcpClient}`);
+      }
+
+    } catch (err: any) {
+      throw new BadRequestException(`Invalid MCP executable or client path: ${err.message}`);
+    }
+
+    // TODO: Refactor to use the command.service.ts instead...
+    return new Promise((resolve, reject) => {
+      this.logger.log(`Attempting to run command:`)
+      this.logger.log(`${pythonExecutable} ${mcpClient} "${prompt}"`);
+
+      const python = spawn(pythonExecutable, [mcpClient, `"${prompt}"`]);
+
+      let stdout = '';
+      let stderr = '';
+
+      python.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      python.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      python.on('close', (code) => {
+        this.logger.log(`Python script exited with code ${code}`);
+
+        if (code !== 0) {
+          this.logger.error(`Python script exited with a non-zero exit code: ${stderr}`);
+          return reject(new Error(`Python script exited with a non-zero exit code: ${stderr}`));
+        }
+
+        try {
+          this.logger.log(`Python script exited with zero exit code: ${stdout}`);
+          const raw: McpResponse = JSON.parse(stdout);
+
+          // Sometimes the raw.response might not be a valid json
+          // TODO: examine the content type of the raw response..
+          // if (raw.content_type==='json') {
+          // }
+          let parsedResponse = raw.response;
+          try {
+            parsedResponse = JSON.parse(raw.response);
+          }
+          catch (ex) {
+            this.logger.warn(`Attempting to parse mcp client response assuming it is JSON, however it is not: ${parsedResponse}`);
+            // raw.success = false
+          }
+          // Parse the response string into an object
+          // const parsedResponse = JSON.parse(raw.response);
+
+          // Replace the string with the parsed object
+          const enrichedRaw = {
+            ...raw,
+            response: parsedResponse,
+          };
+          // if (!raw.success) {
+          //   return reject(new Error(`MCP error: ${raw.errors?.join(', ')}`));
+          // }
+          // let cleaned = raw.response.trim();
+
+          // Don't need to re-parse this...
+          // const parsed = JSON.parse(cleaned);
+          // resolve(cleaned);
+
+          resolve(enrichedRaw);
+        } catch (err: any) {
+          reject(new Error(`Mcp Invocation Failed: ${err.message}`));
+        }
+      });
+    });
+  }
+
+  cleanResponse(response: string) {
+    this.logger.log(`mcp server response is: ${response}`);
+
+    // Remove markdown-style code block wrapper
+    if (response.startsWith('```json')) {
+      response = response.replace(/^```json/, '').trim();
+    }
+    if (response.endsWith('```')) {
+      response = response.replace(/```$/, '').trim();
+    }
+    this.logger.log(`mcp server response after removing doc tags is: ${response}`);
+
+    return response;
+  }
+
+  async applySolidAiInteraction(id: number) {
+    // Fetch the aiInteraction
+    const aiInteraction = await this.findOne(id, {
+      populate: ['user']
+    });
+    if (!aiInteraction) {
+      const m = `Unable to identified the aiInteraction entry that triggered this job... using id: ${id}`
+
+      // TODO: RESPONSE SHAPE ALERT Check if we want to control the shape of the response....
+      throw new Error(m);
+    }
+
+    // TODO: Validation: Check if JSON.parse(metadata).tools_invoked starts with solid_
+    let metadata: any = {};
+    try {
+      if (typeof aiInteraction.metadata === "string") {
+        metadata = JSON.parse(aiInteraction.metadata);
+      } else if (typeof aiInteraction.metadata === "object" && aiInteraction.metadata !== null) {
+        metadata = aiInteraction.metadata;
+      } else {
+        // optional fallback
+        metadata = {};
+      }
+    } catch (e) {
+      // TODO: RESPONSE SHAPE ALERT Check if we want to control the shape of the response....
+      throw new Error(`Invalid metadata JSON: ${e}`);
+    }
+
+    const toolsInvoked = metadata['tools_invoked'];
+    if (!toolsInvoked) {
+      // TODO: RESPONSE SHAPE ALERT Check if we want to control the shape of the response....
+      throw new Error(ERROR_MESSAGES.UNABLE_TO_RESOLVE_SOLID_COMMAND);
+    }
+
+    // TODO: OPTIMISATION for chained tool invocation, for now we are assuming only 1 tool was used.
+    const toolInvoked = toolsInvoked[0];
+
+    // TODO: use the toolInvoked to identify a service using some convention.
+    // TODO: Eg. if toolInvoked is solid_create_module <> SolidCreateModuleMcpToolHandler ... create a factory class to do this mapping and identify the relevant provider. 
+    const mcpToolHandler = this.mcpHandlerFactory.getInstance(toolInvoked);
+    if (!mcpToolHandler) {
+      // TODO: RESPONSE SHAPE ALERT Check if we want to control the shape of the response....
+      throw new Error(ERROR_MESSAGES.UNABLE_TO_RESOLVE_MCP_HANDLER);
+    }
+
+    const handlerApplicationResponse = await mcpToolHandler.apply(aiInteraction);
+
+    // TODO: This provider to implement an interface - IMcpToolResponseHandler ... apply(aiInteraction: AiInteraction)
+    // throw new Error('Method not implemented.');
+
+    // Mark the interaction as applied
+    await this.update(aiInteraction.id, { isApplied: true }, [], true);
+
+    return handlerApplicationResponse;
+  }
+}