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

package/src/platform.js

@@ -1,83 +1,239 @@
 import colors from 'kleur';
 import { z } from 'zod';
-import { build as _build, deploy as _deploy, run as _run, sync as _sync } from './core/index.js';
+import {
+  build as _build,
+  deploy as _deploy,
+  run as _run,
+  runConfig as _runConfig,
+  sync as _sync,
+  test as _test
+} from './core/index.js';
 import { loadConfig, loadEnvConfig } from './core/config/index.js';
-import { coalesceToError } from './utils/index.js';
+import { coalesceToError, ProgressLogger } from './utils/index.js';
+import ProjectFiles from './utils/project.js';
+import { logUserValidationError, report } from './report.js';
 
+/**
+ * Collection of Scout9 Platform commands
+ */
 export const Scout9Platform = {
-  sync:  async function ({cwd = process.cwd()} = {}, mode = 'production') {
+  /**
+   * Syncs the project with the Scout9 account
+   * @param {Object} params
+   * @param {string} [params.cwd=process.cwd()] - the working directory
+   * @param {string} [params.src='src'] - the source directory
+   * @param {string} [params.mode='production'] - the build mode
+   * @returns {Promise<import('./runtime/client/config.js').IScout9ProjectBuildConfig>}
+   */
+  sync: async function ({cwd = process.cwd(), src = 'src', mode = 'production'} = {}) {
+    const logger = new ProgressLogger();
+    const messages = [];
     try {
-      const config = await loadConfig({cwd, folder: 'src'});
-      const result = await _sync({cwd, folder: 'src'}, config);
-      return {
-        config,
-        sync: result
-      };
+      logger.log(`Loading Local Config...`);
+      const projectFiles = new ProjectFiles({cwd, src, autoSave: true, logger});
+      const config = await projectFiles.load();
+      logger.success('Local Config Loaded');
+      logger.log(`Syncing project...`);
+      const result = await _sync({cwd, src, logger, projectFiles}, config);
+      logger.success('Sync Complete');
+      report(config, logger);
+      messages.forEach((m) => logger.info(m));
+      logger.done();
+      return result;
     } catch (e) {
+      logger.done();
       this.handleError(e);
     }
   },
 
   /**
    * Builds & Deploys the project
+   * @param {Object} params
+   * @param {string} [params.cwd=process.cwd()] - the working directory
+   * @param {string} [params.src='./src'] - the source directory
+   * @param {string} [params.dest='/tmp/project'] - the destination directory
+   * @param {'development' | 'production'} [params.mode='production'] - the build mode
+   * @param {boolean} [params.sync=true] - whether to sync the project after deploying
+   * @returns {Promise<import('./runtime/client/config.js').IScout9ProjectBuildConfig>}
    */
-  deploy:  async function ({cwd = process.cwd()} = {}, mode = 'production') {
+  deploy: async function (
+    {
+      cwd = process.cwd(),
+      src = './src',
+      dest = '/tmp/project',
+      mode = 'production',
+      sync = true
+    } = {}
+  ) {
+    const logger = new ProgressLogger();
+    const messages = [];
     try {
-      const config = await loadConfig({cwd, folder: 'src' });
-      await _build({cwd}, config);
-      await _deploy({cwd}, config);
+      // @TODO replace loadConfig with ProjectFiles class
+      logger.log(`Loading config...`);
+      let config = await loadConfig({cwd, src, deploying: true, dest, logger, cb: (m) => messages.push(m)});
+      logger.success('Config Loaded');
+      // await _build({cwd, src, dest, mode, logger}, config);
+      logger.log(`Deploying project...`);
+      const {contacts} = await _deploy({cwd, src, dest, logger}, config);
+      report(config, logger);
+      logger.success(`Deploy Complete\n\n`);
+      if (sync) {
+        logger.log(`Syncing project...`);
+        const projectFiles = new ProjectFiles({cwd, src, autoSave: true, logger});
+        config = await projectFiles.load();
+        const result = await _sync({cwd, src, logger, projectFiles}, config);
+        if (result.success) {
+          logger.success('Sync Complete');
+          config = result.config;
+        } else {
+          logger.error('Sync Failed');
+        }
+      } else {
+        logger.warn(`Syncing project... skipped`);
+      }
+
+      logger.write(`\tApplication will be live for the following channels in a few moments:\n${contacts}`);
+      logger.done();
+      messages.forEach((m) => logger.info(m));
       return config;
     } catch (e) {
+      logger.done();
+      this.handleError(e);
+    }
+  },
+  /**
+   * Tests the project
+   * @param {Object} params
+   * @param {string} [params.cwd=process.cwd()] - the working directory
+   * @param {string} [params.src='./src'] - the source directory
+   * @param {string} [params.dest='/tmp/project'] - the destination directory
+   * @param {'development' | 'production'} [params.mode='production'] - the build mode
+   * @returns {Promise<import('./runtime/client/config.js').IScout9ProjectBuildConfig>}
+   */
+  test: async function ({cwd = process.cwd(), src = './src', dest = '/tmp/project', mode = 'production'} = {}) {
+    const logger = new ProgressLogger();
+    const messages = [];
+    try {
+      logger.log(`Loading test data...`);
+      const config = await loadConfig({cwd, src, logger, cb: (m) => messages.push(m)});
+      logger.success('Test data loaded');
+      logger.log(`Testing project...`);
+      await _test({cwd, src, dest, logger}, config);
+      report(config, logger);
+      messages.forEach((m) => logger.info(m));
+      logger.success(`Test complete`);
+      logger.done();
+      return config;
+    } catch (e) {
+      logger.done();
       this.handleError(e);
     }
   },
-
   /**
    * Builds the project
+   * @param {Object} params
+   * @param {string} [params.cwd=process.cwd()] - the working directory
+   * @param {string} [params.src='./src'] - the source directory
+   * @param {string} [params.dest='/tmp/project'] - the destination directory
+   * @param {'development' | 'production'} [params.mode='production'] - the build mode
+   * @returns {Promise<import('./runtime/client/config.js').IScout9ProjectBuildConfig>}
    */
-  build: async function({cwd = process.cwd(), mode = 'production'} = {}) {
+  build: async function ({cwd = process.cwd(), src = './src', dest = '/tmp/project', mode = 'production'} = {}) {
+    const logger = new ProgressLogger();
+    const messages = [];
     try {
-      const config = await loadConfig({cwd, folder: 'src'});
-      await _build({cwd}, config);
+      logger.log(`Loading config...`);
+      const config = await loadConfig({
+        cwd, src, mode, logger, cb: (m) => {
+          logger.info(m);
+        }
+      });
+      logger.success('Config Loaded');
+      logger.log(`Building project...`);
+      await _build({cwd, src, dest, mode, logger}, config);
+      report(config, logger);
+      messages.forEach((m) => logger.info(m));
+      logger.success('Build Complete');
+      logger.done();
       return config;
+    } catch (e) {
+      logger.done();
+      this.handleError(e);
+    }
+  },
+
+  /**
+   * Loads the project config
+   * @param {Object} params
+   * @param {string} [params.cwd=process.cwd()] - the working directory
+   * @param {boolean} [params.local=false] - whether to only load the local config (ignores what's saved on server)
+   * @param {string} [params.src='./src'] - the source directory
+   * @returns {Promise<import('./runtime/client/config.js').IScout9ProjectBuildConfig>}
+   */
+  config: async function ({cwd = process.cwd(), local = false, src = './src'} = {}) {
+    try {
+      loadEnvConfig({cwd});
+      if (local) {
+        const projectFiles = new ProjectFiles({cwd, src, autoSave: false});
+        return projectFiles.load();
+      } else {
+        return _runConfig();
+      }
+
     } catch (e) {
       this.handleError(e);
+      throw e;
     }
   },
 
   /**
    * Runs the project in a container
+   * @param {import('./runtime/client/workflow.js').IWorkflowEvent} event - every workflow receives an event object
+   * @param {Object} options
+   * @param {string} [options.cwd=process.cwd()] - the working directory
+   * @param {string} [options.mode='production'] - the build mode
+   * @param {string} [options.src='./src'] - the source directory
+   * @param {string} options.eventSource - the source of the workflow event
+   * @returns {Promise<import('./runtime/client/workflow.js').IWorkflowResponse>}
    */
   run: async function (
     event,
-    {cwd = process.cwd(), mode = 'remote', folder}
+    {cwd = process.cwd(), mode = 'production', src = './src', eventSource}
   ) {
-    if (mode !== 'remote') {
-      throw new Error(`Unimplemented mode "${mode}"`);
-    }
     try {
       loadEnvConfig({cwd});
-      return _run(event, {cwd, folder});
+      return _run(event, {cwd, src, mode, eventSource})
+        .catch(e => {
+          throw e;
+        });
     } catch (e) {
       this.handleError(e);
       throw e;
     }
   },
+
+
   handleError: function (e) {
     const error = coalesceToError(e);
 
-    if (error.name === 'SyntaxError') throw error;
+    switch (error.name) {
+      case 'SyntaxError':
+        throw error;
+      case 'ZodError':
+        logUserValidationError(error, error.source || 'src/index.js|ts');
+        break;
+      default:
+        console.error(colors.bold().red(`> ${error.message}`));
+        if (error instanceof z.ZodError) {
+          console.error(error.issues.map(i => colors.red(`${colors.bold(`\tZod Error (${i.code}): `)}"${i.message}" ${JSON.stringify(
+            i.path)}`)).join('\n'));
+          console.error(colors.gray(JSON.stringify(error.format(), null, 2)));
+        }
 
-    console.error(colors.bold().red(`> ${error.message}`));
-    if (error instanceof z.ZodError) {
-      console.error(error.issues.map(i => colors.red(`${colors.bold(`\tZod Error (${i.code}): `)}"${i.message}" ${JSON.stringify(i.path)}`)).join('\n'));
-      console.error(colors.gray(JSON.stringify(error.format(), null, 2)));
+        if (error.stack) {
+          console.error(colors.gray(error.stack.split('\n').slice(0).join('\n')));
+        }
     }
-
-    if (error.stack) {
-      console.error(colors.gray(error.stack.split('\n').slice(0).join('\n')));
-    }
-
     process.exit(1);
   }
-}
+};

package/src/public.d.ts.text

@@ -0,0 +1,330 @@
+
+/**
+ * Represents the configuration provided in src/index.{js | ts} in a project
+ * @deprecated use IScout9ProjectConfig
+ */
+export interface Scout9ProjectConfig {
+
+  /**
+   * Tag to reference this application
+   * @defaut your local package.json name + version, or scout9-app-v1.0.0
+   */
+  tag?: string;
+
+  llm: {
+    engine: 'openai',
+    model: (string & {})
+      | 'gpt-4-1106-preview'
+      | 'gpt-4-vision-preview'
+      | 'gpt-4'
+      | 'gpt-4-0314'
+      | 'gpt-4-0613'
+      | 'gpt-4-32k'
+      | 'gpt-4-32k-0314'
+      | 'gpt-4-32k-0613'
+      | 'gpt-3.5-turbo'
+      | 'gpt-3.5-turbo-16k'
+      | 'gpt-3.5-turbo-0301'
+      | 'gpt-3.5-turbo-0613'
+      | 'gpt-3.5-turbo-16k-0613';
+  } | {
+    engine: 'bard' | 'gemini' | 'llama',
+    model: string;
+  },
+  /**
+   * Configure personal model transformer (PMT) settings to align auto replies the agent's tone
+   */
+  pmt: {
+    engine: 'scout9',
+    model: 'orin-1.0' | 'orin-2.0-preview'
+  }
+
+  /**
+   * Determines the max auto replies without further conversation progression (defined by new context data gathered)
+   * before the conversation is locked and requires manual intervention
+   * @default 3
+   */
+  maxLockAttempts?: number;
+
+  /**
+   * Configure the initial contexts for every conversation
+   */
+  initialContext: string[];
+  organization: {
+    name: string;
+    description: string;
+    dashboard?: string;
+    logo?: string;
+    icon?: string;
+    logos?: string;
+    website?: string;
+    email?: string;
+    phone?: string;
+  }
+}
+
+/**
+ * Entity config the user provides
+ * @deprecated use IEntityConfiguration
+ */
+export interface EntityBuildConfig {
+  definitions?: {
+    utterance?: string;
+    value: string;
+    text: string[];
+  }[],
+  training?: {
+    text: string, intent: string;
+  }[];
+  tests?: {
+    text: string;
+    expected: {
+      intent: string;
+      context: any;
+    }
+  }[];
+}
+
+/**
+ * What gets exported to the scout9 backend, properties are constructed by @scout/app build
+ * @deprecated use IEntityRootProjectConfiguration instead
+ */
+export interface ExportedEntityBuildConfig extends EntityBuildConfig {
+  entities: string[];
+  entity: string;
+  // id: string;
+  api: {
+    QUERY?: boolean;
+    GET?: boolean;
+    POST?: boolean;
+    PUT?: boolean;
+    PATCH?: boolean;
+    DELETE?: boolean;
+  } | null;
+}
+
+/**
+ * @deprecated use IEntitiesRootProjectConfiguration instead
+ */
+export type EntitiesBuildConfig = ExportedEntityBuildConfig[];
+
+/**
+ * @deprecated use IWorkflowConfiguration instead
+ */
+export type WorkflowBuildConfig = {
+  entities: string[];
+  entity: string;
+}
+
+/**
+ * @deprecated use IWorkflowsConfiguration instead
+ */
+export type WorkflowsBuildConfig = WorkflowBuildConfig[];
+
+/**
+ * Including the provided project config, this is the manifest for all entities and workflows to be managed in build
+ * @deprecated IScout9ProjectBuildConfig
+ */
+export interface Scout9ProjectBuildConfig extends Scout9ProjectConfig {
+  agents: Agent[];
+  entities: EntitiesBuildConfig;
+  workflows: WorkflowsBuildConfig;
+}
+
+
+export interface DeployOptions {
+  cwd?: string;
+}
+
+export interface BuildOptions {
+  cwd?: string;
+  mode?: 'development' | 'production';
+}
+
+export interface RunOptions {
+  cwd?: string;
+  mode?: 'remote' | 'local';
+}
+
+/**
+ * @deprecated use IConversation
+ */
+export interface Conversation {
+  $agent: string;
+  $customer: string;
+  initialContexts?: string[];
+  environment: 'phone' | 'email' | 'web';
+  environmentProps?: {
+    subject?: string;
+    platformEmailThreadId?: string;
+  };
+  locked?: boolean;
+  lockedReason?: string;
+  lockAttempts?: number;
+  forwardedTo?: string; // personaId/phone/email
+  forwarded?: string; // ISO 8601
+  forwardNote?: string;
+
+  /**
+   * Detected intent
+   */
+  intent?: string | null;
+
+  /**
+   * Confidence score of the assigned intent
+   */
+  intentScore?: number | null;
+}
+
+/**
+ * @typedef {import('./runtime/client/message.js').IMessage} IMessage
+ * @deprecated use IMessage
+ */
+export interface Message {
+  id: string;
+
+  role: 'customer' | 'agent' | 'system';
+  content: string;
+  name?: string;
+  time: string;
+
+  scheduled?: string;
+  delayInSeconds?: number;
+
+  /**
+   * The context generated from the message
+   */
+  context?: any;
+
+  /**
+   * Detected intent
+   */
+  intent?: string | null;
+
+  /**
+   * Confidence score of the assigned intent
+   */
+  intentScore?: number | null;
+}
+
+/**
+ * @deprecated use ICustomer
+ */
+export interface Customer {
+  id: string;
+  name: string;
+  firstName?: string;
+  lastName?: string;
+  email?: string;
+  phone?: string;
+  img?: string;
+  neighborhood?: string;
+  city?: string;
+  country?: string;
+  line1?: string;
+  line2?: string;
+  postal_code?: string;
+  state?: string;
+  town?: string;
+
+  [key: string]: any;
+}
+
+/**
+ * @deprecated use IAgent
+ */
+export interface Agent {
+  // Generated Info
+  id: string;
+  deployed?: {
+    web?: string;
+    phone?: string;
+    email?: string;
+  };
+
+  /**
+   * Profile image path
+   */
+  img?: string | Buffer;
+
+  firstName?: string;
+  lastName?: string;
+  inactive?: boolean;
+  programmablePhoneNumber?: string;
+  programmablePhoneNumberSid?: string;
+  programmableEmail?: string;
+  forwardEmail?: string;
+  forwardPhone?: string;
+  title?: string;
+  context?: string;
+  includedLocations?: string[];
+  excludedLocations?: string[];
+  model?: 'Scout9' | 'bard' | 'openai';
+  transcripts?: Message[][];
+  audios?: any[];
+}
+
+/**
+ * @deprecated use IPersona
+ */
+export type Persona = Agent;
+
+/**
+ * The input event provided to the application
+ * @deprecated use IWorkflowEvent
+ */
+export interface WorkflowEvent<Type = any> {
+  messages: Message[];
+  conversation: Conversation;
+  context: Partial<Type>;
+  message: Message;
+  agent: Omit<Agent, 'transcripts' | 'audios' | 'includedLocations' | 'excludedLocations' | 'model' | 'context'>;
+  customer: Customer;
+  intent: {
+    current: string | null;
+    flow: string[];
+    initial: string | null;
+  };
+  stagnationCount: number;
+}
+
+/**
+ * @deprecated use IInstruction
+ */
+export interface Instruction {
+  id: string;
+  content: string;
+}
+
+/**
+ * @deprecated use IWorkflowResponseSlot
+ */
+export interface WorkflowResponseSlot<Type = any> {
+  forward?: string | boolean | {
+    to?: string;
+    mode?: 'after-reply' | 'immediately';
+
+    /**
+     * Note to provide to the agent
+     */
+    note?: string;
+  };
+  forwardNote?: string;
+  instructions?: string | string[] | Instruction | Instruction[];
+  removeInstructions?: string[];
+  message?: string;
+  secondsDelay?: number;
+  scheduled?: number;
+  contextUpsert?: Partial<Type>;
+  resetIntent?: boolean;
+}
+
+/**
+ * @deprecated use IWorkflowResponse
+ */
+export type WorkflowResponse<Type = any> = WorkflowResponseSlot<Type> | WorkflowResponseSlot<Type>[];
+
+/**
+ * @deprecated use IWorkflowFunction
+ */
+export type WorkflowFunction<Type = any> = (event: WorkflowEvent) => Promise<WorkflowResponse<Type>> | WorkflowResponse<Type>;