@scout9/app 1.0.0-alpha.0.1.9 → 1.0.0-alpha.0.1.90

package/src/utils/glob.js

@@ -0,0 +1,30 @@
+export function normalizeGlobPattern(pattern) {
+  let normalizedPattern = pattern;
+  let matchFound = /\{([^,]+),?.*?\}/.test(normalizedPattern);
+  let iterations = 0; // Safeguard against potential infinite loops
+  const maxIterations = 100; // Set a reasonable limit based on expected complexity
+
+  while (matchFound && iterations < maxIterations) {
+    normalizedPattern = normalizedPattern.replace(/\{([^,]+),?.*?\}/, '$1');
+    matchFound = /\{([^,]+),?.*?\}/.test(normalizedPattern);
+    iterations++;
+  }
+
+  if (iterations >= maxIterations) {
+    console.warn('Reached max iterations - pattern may be too complex or improperly formatted');
+  }
+
+  return normalizedPattern;
+}
+
+function escapeSquareBrackets(pattern) {
+  // Escaping both opening and closing square brackets
+  return pattern.replace(/\[/g, '\\[').replace(/\]/g, '\\]');
+}
+
+export function formatGlobPattern(pattern) {
+  return escapeSquareBrackets(pattern);
+}
+
+
+

package/src/utils/image-buffer.js

@@ -0,0 +1,23 @@
+import { toBuffer } from './file.js';
+import { imageExtensions } from './image-type.js';
+import { isSvg } from './is-svg.js';
+
+/**
+ *
+ * @param {string | Buffer} img
+ * @param [allowSvg=false]
+ * @param [source='']
+ * @returns {Promise<{buffer: Buffer, ext: string, mime: string, isAudio: boolean, isVideo: boolean, isImage: boolean}>}
+ */
+export default async function imageBuffer(img, allowSvg = false, source = '') {
+  const imageResult = await toBuffer(img, source);
+  if (!imageResult) {
+    throw new Error(`Invalid image type: ${typeof img}`);
+  }
+  if (!imageExtensions.has(imageResult.ext)) {
+    if (!(allowSvg && isSvg(img.toString('utf-8')))) {
+      throw new Error(`Invalid image type: ${imageResult.ext}`);
+    }
+  }
+  return imageResult;
+}

package/src/utils/image-type.js

@@ -0,0 +1,39 @@
+import { fileTypeFromBuffer } from './file-type.js';
+
+export const imageExtensions = new Set([
+  'jpg',
+  'png',
+  'gif',
+  'webp',
+  'flif',
+  'cr2',
+  'tif',
+  'bmp',
+  'jxr',
+  'psd',
+  'ico',
+  'bpg',
+  'jp2',
+  'jpm',
+  'jpx',
+  'heic',
+  'cur',
+  'dcm',
+  'avif'
+]);
+
+/**
+ * @typedef {Object} ImageTypeResult
+ * @property {string} ext - One of the supported [file types](https://github.com/sindresorhus/image-type#supported-file-types).
+ * @property {string} mime - The detected [MIME type](https://en.wikipedia.org/wiki/Internet_media_type).
+ */
+
+/**
+ *
+ * @param {Buffer | Uint8Array} input
+ * @returns {Promise<ImageTypeResult | undefined>}
+ */
+export default async function imageType(input) {
+  const result = await fileTypeFromBuffer(input);
+  return imageExtensions.has(result?.ext) && result;
+}

package/src/utils/index.js

@@ -1,3 +1,4 @@
 export * from './error.js';
+export * from './logger.js';
 export * from './module.js';
 export * from './stats.js';

package/src/utils/is-svg.js

@@ -0,0 +1,37 @@
+import { XMLParser, XMLValidator } from 'fast-xml-parser';
+
+export function isSvg(str) {
+  if (typeof str !== 'string') {
+    throw new TypeError(`Expected a \`string\`, got \`${typeof str}\``);
+  }
+
+  str = str.trim();
+
+  if (str.length === 0) {
+    return false;
+  }
+
+  // Has to be `!==` as it can also return an object with error info.
+  if (XMLValidator.validate(str) !== true) {
+    return false;
+  }
+
+  let jsonObject;
+  const parser = new XMLParser();
+
+  try {
+    jsonObject = parser.parse(str);
+  } catch {
+    return false;
+  }
+
+  if (!jsonObject) {
+    return false;
+  }
+
+  if (!('svg' in jsonObject)) {
+    return false;
+  }
+
+  return true;
+}

package/src/utils/logger.js

@@ -0,0 +1,111 @@
+import readline from 'node:readline';
+import logUpdate from 'log-update';
+import colors from 'kleur';
+
+export class ProgressLogger {
+  constructor(initialMessage = null) {
+    this.lines = [];
+    this._indents = 0;
+    this._interval = -1;
+    this._frames = [
+      "010010",
+      "001100",
+      "100101",
+      "111010",
+      "111101",
+      "010111",
+      "101011",
+      "111000",
+      "110011",
+      "110101"
+    ]
+    this._framesSpeed = 80;
+    if (initialMessage) {
+      this.log(initialMessage);
+      this.write(initialMessage)
+    }
+  }
+
+  set indents(value) {
+    this._indents = value;
+  }
+
+  log(message, ...args) {
+    const formatted = this._format(message);
+
+    // const frames = ['-', '\\', '|', '/'];
+    let index = 0;
+
+    logUpdate.clear();
+    clearInterval(this._interval);
+    this._interval = setInterval(() => {
+      const frame = this._frames[index = ++index % this._frames.length];
+      logUpdate(`${colors.bold(colors.green(frame))}: ${colors.white(formatted)}`);
+    }, this._framesSpeed);
+
+    this.lines.push({message: formatted, type: 'log'});
+  }
+
+  info(message, ...args) {
+    return this.write('\t - ' + colors.italic(colors.gray(message)));
+  }
+
+  primary(message, ...args) {
+    return this.write(`${colors.cyan(message)}`);
+  }
+
+  success(message, ...args) {
+    return this.write(`✅  ${colors.green(message)}`);
+  }
+
+  error(message, ...args) {
+    return this.write(`❌  ${colors.red(message)}`);
+  }
+
+  warn(message, ...args) {
+    return this.write(`⚠️ ${colors.yellow(message)}`);
+  }
+
+  write(newMessage) {
+    if (this.lines.length === 0) {
+      throw new Error("No lines to update");
+    }
+
+    logUpdate.clear();
+    clearInterval(this._interval);
+    logUpdate.done();
+
+    // Update the last line in the array
+    const lastLine = this.lines[this.lines.length - 1];
+    if (lastLine.type === 'log') {
+      // Replace the last log line
+      this.lines[this.lines.length - 1] = {message: this._format(newMessage), type: 'written'};
+    } else {
+      // Append the new line
+      this.lines.push({message: this._format(newMessage), type: 'written'});
+    }
+
+    // Clear all the logged lines and reprint them
+    readline.moveCursor(process.stdout, 0, -this.lines.length);
+    readline.clearScreenDown(process.stdout);
+    this.lines.forEach(line => console.log(line.message));
+
+    // // Move up to the last line
+    // readline.moveCursor(process.stdout, 0, -1);
+    // readline.clearLine(process.stdout, 0);
+    // readline.cursorTo(process.stdout, 0);
+
+    // Log the updated line
+    // console.log(newMessage);
+  }
+
+  done() {
+    logUpdate.clear();
+    logUpdate.done();
+  }
+
+  _format(message) {
+    const indentText = '\t'.repeat(this._indents);
+    return `${indentText}${message}`;
+  }
+}

package/src/utils/module.js

@@ -1,23 +1,8 @@
-async function importFile(filePath) {
-  return import(filePath);
-  //
-  // if (path.extname(filePath) === '.ts') {
-  //   return tsImport.load(filePath, {
-  //     // allowConfigurationWithComments: false,
-  //     useCache: false
-  //   })
-  //     .then((res) => {
-  //       console.log('tsImport.load', res);
-  //       return res;
-  //     })
-  //     .catch((err) => {
-  //       console.log('tsImport.load fail', err);
-  //       throw err;
-  //     });
-  // } else {
-  //   return import(filePath);
-  // }
-  //
+import { pathToFileURL } from 'node:url';
+
+export async function importFile(filePath) {
+  const fileUrl = pathToFileURL(filePath);
+  return import(fileUrl.href);
 }
 
 export async function requireProjectFile(filePath) {
@@ -29,11 +14,15 @@ export async function requireProjectFile(filePath) {
 }
 
 export async function requireOptionalProjectFile(filePath) {
-  try {
-    return importFile(filePath).catch(() => null);
-  } catch (e) {
-    return null;
-  }
+  return importFile(filePath).catch((e) => {
+    switch (e.code) {
+      case 'ERR_MODULE_NOT_FOUND':
+      case 'MODULE_NOT_FOUND':
+        return null;
+      default:
+        throw e;
+    }
+  });
 }
 
 

package/src/utils/project-templates.js

@@ -0,0 +1,191 @@
+/**
+ * @param {Scout9ProjectBuildConfig['agents']} agents
+ * @param {string} exe - file extension
+ * @returns {string}
+ */
+function agentsTemplate(agents, exe = 'js') {
+  return `
+/**
+ * Required core entity type: Agents represents you and your team
+ * @returns {Array<import('@scout9/app').IAgent>}
+ */
+export default function Agents() {
+  return ${JSON.stringify(agents, null, 2)};
+}
+`;
+}
+
+/**
+ * @param {Scout9ProjectBuildConfig} config
+ * @param {string} exe - file extension
+ * @returns {string}
+ *
+ */
+function rootTemplate(config, exe = 'js') {
+  return `
+/**
+ * Configuration for the Scout9 project.
+ * @type {import('@scout9/app').IScout9ProjectConfig}
+ */
+export default {
+
+  /**
+   * Configure large language model (LLM) settings to generate auto replies
+   */
+  llm: {
+    engine: ${config?.llm?.engine ? `'${config.llm.engine}'` : `'openai'`},
+    model: ${config?.llm?.model ? `'${config.llm.model}'` : `'gpt-3.5-turbo'`},
+  },
+  /**
+   * Configure personal model transformer (PMT) settings to align auto replies the agent's tone
+   */
+  pmt: {
+    engine: ${config?.pmt?.engine ? `'${config.pmt.engine}'` : `'scout9'`},
+    model: ${config?.pmt?.model ? `'${config.pmt.model}'` : `'orin-2.2'`},
+  },
+  organization: ${config?.organization ? JSON.stringify(config.organization, null, 2) : `{name: "Organization Name", description: "Organization description."}`},
+  initialContext: ${config?.initialContext ? JSON.stringify(config.initialContext, null, 2) : `[]`}
+}
+  `;
+}
+
+function appTemplate() {
+  return `
+/**
+ * @param {import('@scout9/app').IWorkflowEvent} event - every workflow receives an event object
+ * @returns {Promise<import('@scout9/app').IWorkflowResponse>} - every workflow must return a WorkflowResponse
+ */
+export default async function Scout9App(event) {
+  return {
+    forward: true,
+  };
+}
+  `;
+}
+
+/**
+ * @param {ExportedEntityBuildConfig} entity
+ * @param {string} exe - file extension
+ */
+function entityTemplate(entity, exe = 'js') {
+  let {entity: _entity, entities, api, id, ...rest} = entity;
+  if (!_entity.endsWith('Entity')) {
+    _entity = `${_entity}Entity`;
+  }
+  return `
+/**
+ * ${rest.description || 'Example entity to help us differentiate if a user wants a delivery or pickup order'}
+ * @returns {IEntityBuildConfig}
+ */
+export default async function ${_entity}() {
+  return ${JSON.stringify(rest, null, 2)};
+}
+  `;
+}
+
+function customersTemplate() {
+  return `
+import Scout9CRM from '@scout9/crm';
+import { EventResponse } from '@scout9/app';
+
+const crm = new Scout9CRM({apiKey: process.env.SCOUT9_API_KEY});
+
+
+/**
+ * Required entity - use this to sync with your CRM
+ *
+ * Query customer info from your CRM
+ * @returns {Promise<import('@scout9/app').EventResponse<Array<import('@scout9/app').Customer>>>}
+ */
+export const QUERY = async ({searchParams}) => {
+  const {page, q, orderBy, endAt, startAt, limit} = searchParams;
+  const customers = await crm.query(
+    q,
+    page ? parseInt(page) : undefined,
+    limit ? parseInt(limit) : undefined,
+    orderBy ? parseInt(orderBy) : undefined,
+    endAt ? parseInt(endAt) : undefined,
+    startAt ? parseInt(startAt) : undefined,
+  );
+  return EventResponse.json(customers, {status: 200});
+}  
+  `;
+}
+
+function customerTemplate() {
+  return `
+import Scout9CRM from '@scout9/crm';
+import { json } from '@scout9/app';
+
+const crm = new Scout9CRM({apiKey: process.env.SCOUT9_API_KEY});
+
+/**
+ * Get customer info from your CRM
+ * @returns {Promise<import('@scout9/app').EventResponse<import('@scout9/app').Customer>>}
+ */
+export const GET = async ({params}) => {
+  return json(await crm.get(params.customer));
+};
+
+/**
+ * When a customer is created on scout9's side
+ *
+ * Example:
+ *    A new or unrecognized customer has contacted an agent. Scout9 has captured some preliminary information
+ *    about them and sent this POST request. Take the information to either add a new customer record to your CRM
+ *    or return an existing customer id to map the correct customer document.
+ *
+ * @returns {Promise<import('@scout9/app').EventResponse>}
+ */
+export const POST = async ({params, body: newCustomer}) => {
+  // Scout9 will generate random id for new customers, but whatever id you return back will be used for the new customer
+  const {id: crmId} = await crm.add({$id: params.customer, newCustomer});
+  return json({success: true, id: crmId}, {status: 200});
+};
+
+/**
+ * New customer info revealed, use this to save the customer info to your CRM
+ *
+ * Example:
+ *    In a conversation, if any new data is found, Scout9 will send a PUT or PATCH request to allow for you to update
+ *    your CRM accordingly.
+ *
+ * @returns {Promise<import('@scout9/app').EventResponse>}
+ */
+export const PUT = async ({params, body: updatedCustomer}) => {
+  // const id = params.customer;
+
+  console.log('updatedCustomer', updatedCustomer);
+  // @TODO REST call  to api to save customer info
+
+  // @TODO REST call to api to save customer info
+  return json({success: true}, {status: 200});
+};
+
+
+/**
+ * Customer request to be removed from platform, use this to remove/update the customer info from your CRM
+ *
+ * Example:
+ *    A customer has opt-out of text messaging, Scout9 will send a DELETE message for you to remove any data, returning
+ *    back success: true will then have Scout9 delete any data on their end as well.
+ *
+ * @returns {Promise<import('@scout9/app').EventResponse>}
+ */
+export const DELETE = async ({params, request}) => {
+  await crm.remove(params.customer);
+  return json({success: true}, {status: 200});
+}; 
+`
+}
+
+export const projectTemplates = {
+  entities: {
+    agents: agentsTemplate,
+    entity: entityTemplate,
+    customers: customersTemplate,
+    customer: customerTemplate,
+  },
+  root: rootTemplate,
+  app: appTemplate
+}