@proteinjs/conversation 1.0.5 → 1.0.7

package/src/OpenAi.ts

@@ -7,26 +7,38 @@ import { MessageHistory } from './history/MessageHistory';
 import { TiktokenModel } from 'tiktoken';
 
 function delay(ms: number) {
-  return new Promise(resolve => setTimeout(resolve, ms));
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
 export const DEFAULT_MODEL: TiktokenModel = 'gpt-3.5-turbo';
 export class OpenAi {
-  static async generateResponse(messages: string[], model?: string, history?: MessageHistory, functions?: Function[], messageModerators?: MessageModerator[], logLevel: LogLevel = 'info'): Promise<string> {
+  static async generateResponse(
+    messages: string[],
+    model?: string,
+    history?: MessageHistory,
+    functions?: Function[],
+    messageModerators?: MessageModerator[],
+    logLevel: LogLevel = 'info'
+  ): Promise<string> {
     const logger = new Logger('OpenAi.generateResponse', logLevel);
-    const messageParams: ChatCompletionMessageParam[] = messages.map(message => { return { role: 'user', content: message }});
-    if (history)
+    const messageParams: ChatCompletionMessageParam[] = messages.map((message) => {
+      return { role: 'user', content: message };
+    });
+    if (history) {
       history.push(messageParams);
+    }
     let messageParamsWithHistory = history ? history : new MessageHistory().push(messageParams);
-    if (messageModerators)
+    if (messageModerators) {
       messageParamsWithHistory = OpenAi.moderateHistory(messageParamsWithHistory, messageModerators);
+    }
     const response = await OpenAi.executeRequest(messageParamsWithHistory, logLevel, functions, model);
     const responseMessage = response.choices[0].message;
     if (responseMessage.function_call) {
       messageParamsWithHistory.push([responseMessage]);
       const functionReturnMessage = await this.callFunction(logLevel, responseMessage.function_call, functions);
-      if (functionReturnMessage)
-        messageParamsWithHistory.push([functionReturnMessage])
+      if (functionReturnMessage) {
+        messageParamsWithHistory.push([functionReturnMessage]);
+      }
       return await this.generateResponse([], model, messageParamsWithHistory, functions, messageModerators, logLevel);
     }
 
@@ -41,50 +53,61 @@ export class OpenAi {
   }
 
   private static moderateHistory(history: MessageHistory, messageModerators: MessageModerator[]) {
-    for (let messageModerator of messageModerators)
+    for (const messageModerator of messageModerators) {
       history.setMessages(messageModerator.observe(history.getMessages()));
+    }
 
     return history;
   }
 
-  private static async executeRequest(messageParamsWithHistory: MessageHistory, logLevel: LogLevel, functions?: Function[], model?: string): Promise<ChatCompletion> {
+  private static async executeRequest(
+    messageParamsWithHistory: MessageHistory,
+    logLevel: LogLevel,
+    functions?: Function[],
+    model?: string
+  ): Promise<ChatCompletion> {
     const logger = new Logger('OpenAi.executeRequest', logLevel);
     const openaiApi = new OpenAIApi();
     let response: ChatCompletion;
     try {
       const latestMessage = messageParamsWithHistory.getMessages()[messageParamsWithHistory.getMessages().length - 1];
-      if (latestMessage.content)
+      if (latestMessage.content) {
         logger.info(`Sending request: ${latestMessage.content}`);
-      else if (latestMessage.role == 'function')
+      } else if (latestMessage.role == 'function') {
         logger.info(`Sending request: returning output of ${latestMessage.name} function`);
-      else
+      } else {
         logger.info(`Sending request`);
+      }
       logger.debug(`Sending messages: ${JSON.stringify(messageParamsWithHistory.getMessages(), null, 2)}`, true);
       response = await openaiApi.chat.completions.create({
         model: model ? model : DEFAULT_MODEL,
         temperature: 0,
         messages: messageParamsWithHistory.getMessages(),
-        functions: functions?.map(f => f.definition),
+        functions: functions?.map((f) => f.definition),
       });
       const responseMessage = response.choices[0].message;
-      if (responseMessage.content)
+      if (responseMessage.content) {
         logger.info(`Received response: ${responseMessage.content}`);
-      else if (responseMessage.function_call)
+      } else if (responseMessage.function_call) {
         logger.info(`Received response: call ${responseMessage.function_call.name} function`);
-      else
+      } else {
         logger.info(`Received response`);
-      if (response.usage)
+      }
+      if (response.usage) {
         logger.info(JSON.stringify(response.usage));
-      else
+      } else {
         logger.info(JSON.stringify(`Usage data missing`));
-    } catch(error: any) {
+      }
+    } catch (error: any) {
       logger.info(`Received error response, error type: ${error.type}`);
       if (typeof error.status !== 'undefined' && error.status == 429) {
         if (error.type == 'tokens' && typeof error.headers['x-ratelimit-reset-tokens'] === 'string') {
           const waitTime = parseInt(error.headers['x-ratelimit-reset-tokens']);
           const remainingTokens = error.headers['x-ratelimit-remaining-tokens'];
           const delayMs = 15000;
-          logger.warn(`Waiting to retry in ${delayMs/1000}s, token reset in: ${waitTime}s, remaining tokens: ${remainingTokens}`);
+          logger.warn(
+            `Waiting to retry in ${delayMs / 1000}s, token reset in: ${waitTime}s, remaining tokens: ${remainingTokens}`
+          );
           await delay(delayMs);
           return await OpenAi.executeRequest(messageParamsWithHistory, logLevel, functions, model);
         }
@@ -96,21 +119,25 @@ export class OpenAi {
     return response;
   }
 
-  private static async callFunction(logLevel: LogLevel, functionCall: ChatCompletionMessage.FunctionCall, functions?: Function[]): Promise<ChatCompletionMessageParam|undefined> {
+  private static async callFunction(
+    logLevel: LogLevel,
+    functionCall: ChatCompletionMessage.FunctionCall,
+    functions?: Function[]
+  ): Promise<ChatCompletionMessageParam | undefined> {
     const logger = new Logger('OpenAi.callFunction', logLevel);
     if (!functions) {
       const warning = `Assistant attempted to call a function when no functions were provided`;
       logger.warn(warning);
-      const message: ChatCompletionMessageParam = { role: 'user', content: warning }
+      const message: ChatCompletionMessageParam = { role: 'user', content: warning };
       return message;
     }
 
     functionCall.name = functionCall.name.split('.').pop() as string;
-    const f = functions.find(f => f.definition.name === functionCall.name);
+    const f = functions.find((f) => f.definition.name === functionCall.name);
     if (!f) {
       const warning = `Assistant attempted to call nonexistent function: ${functionCall.name}`;
       logger.warn(warning);
-      const message: ChatCompletionMessageParam = { role: 'user', content: warning }
+      const message: ChatCompletionMessageParam = { role: 'user', content: warning };
       return message;
     }
 
@@ -118,46 +145,74 @@ export class OpenAi {
     try {
       logger.info(`Assistant calling function: ${f.definition.name}(${functionCall.arguments})`);
       returnObject = JSON.stringify(await f.call(JSON.parse(functionCall.arguments)));
-      logger.info(`Assistant called function: ${f.definition.name}(${functionCall.arguments}) => ${returnObject}`, 1000);
+      logger.info(
+        `Assistant called function: ${f.definition.name}(${functionCall.arguments}) => ${returnObject}`,
+        1000
+      );
     } catch (error: any) {
       logger.error(error.message);
     }
 
-    if (!returnObject)
+    if (!returnObject) {
       return;
+    }
 
     return {
-      role: 'function', 
-      name: f.definition.name, 
+      role: 'function',
+      name: f.definition.name,
       content: returnObject,
     };
   }
 
-  static async generateCode(messages: string[], model?: string, history?: MessageHistory, functions?: Function[], messageModerators?: MessageModerator[], includeSystemMessages: boolean = true, logLevel: LogLevel = 'info') {
+  static async generateCode(
+    messages: string[],
+    model?: string,
+    history?: MessageHistory,
+    functions?: Function[],
+    messageModerators?: MessageModerator[],
+    includeSystemMessages: boolean = true,
+    logLevel: LogLevel = 'info'
+  ) {
     const systemMessages: ChatCompletionMessageParam[] = [
-      { role: 'system', content: 'Return only the code and exclude example usage, markdown, explanations, comments and notes.' },
+      {
+        role: 'system',
+        content: 'Return only the code and exclude example usage, markdown, explanations, comments and notes.',
+      },
       { role: 'system', content: `Write code in typescript.` },
       { role: 'system', content: `Declare explicit types for all function parameters.` },
       { role: 'system', content: 'Export all functions and objects generated.' },
       { role: 'system', content: 'Do not omit function implementations.' },
     ];
-    const resolvedHistory = history ? 
-      includeSystemMessages ?
-        history.push(systemMessages)
-        :
-        history
-      :
-      includeSystemMessages ?
-        new MessageHistory().push(systemMessages)
-        :
-        undefined
-    ;
+    const resolvedHistory = history
+      ? includeSystemMessages
+        ? history.push(systemMessages)
+        : history
+      : includeSystemMessages
+        ? new MessageHistory().push(systemMessages)
+        : undefined;
     const code = await this.generateResponse(messages, model, resolvedHistory, functions, messageModerators, logLevel);
     return this.parseCodeFromMarkdown(code);
   }
 
-  static async updateCode(code: string, description: string, model?: string, history?: MessageHistory, functions?: Function[], messageModerators?: MessageModerator[], includeSystemMessages: boolean = true, logLevel: LogLevel = 'info') {
-    return await this.generateCode([this.updateCodeDescription(code, description)], model, history, functions, messageModerators, includeSystemMessages, logLevel);
+  static async updateCode(
+    code: string,
+    description: string,
+    model?: string,
+    history?: MessageHistory,
+    functions?: Function[],
+    messageModerators?: MessageModerator[],
+    includeSystemMessages: boolean = true,
+    logLevel: LogLevel = 'info'
+  ) {
+    return await this.generateCode(
+      [this.updateCodeDescription(code, description)],
+      model,
+      history,
+      functions,
+      messageModerators,
+      includeSystemMessages,
+      logLevel
+    );
   }
 
   static updateCodeDescription(code: string, description: string) {
@@ -165,22 +220,25 @@ export class OpenAi {
   }
 
   static parseCodeFromMarkdown(code: string) {
-    if (!code.match(/```([\s\S]+?)```/g))
+    if (!code.match(/```([\s\S]+?)```/g)) {
       return code;
+    }
 
     const filteredLines: string[] = [];
     let inCodeBlock = false;
-    for (let line of code.split('\n')) {
+    for (const line of code.split('\n')) {
       if (line.startsWith('```')) {
         inCodeBlock = !inCodeBlock;
-        if (!inCodeBlock)
+        if (!inCodeBlock) {
           filteredLines.push('');
-          
+        }
+
         continue;
       }
 
-      if (inCodeBlock)
+      if (inCodeBlock) {
         filteredLines.push(line);
+      }
     }
 
     // remove the last '' that will become a \n
@@ -190,23 +248,30 @@ export class OpenAi {
     return filteredLines.join('\n');
   }
 
-  static async generateList(messages: string[], model?: string, history?: MessageHistory, functions?: Function[], messageModerators?: MessageModerator[], includeSystemMessages: boolean = true, logLevel: LogLevel = 'info'): Promise<string[]> {
+  static async generateList(
+    messages: string[],
+    model?: string,
+    history?: MessageHistory,
+    functions?: Function[],
+    messageModerators?: MessageModerator[],
+    includeSystemMessages: boolean = true,
+    logLevel: LogLevel = 'info'
+  ): Promise<string[]> {
     const systemMessages: ChatCompletionMessageParam[] = [
-      { role: 'system', content: 'Return only the list and exclude example usage, markdown and all explanations, comments and notes.' },
+      {
+        role: 'system',
+        content: 'Return only the list and exclude example usage, markdown and all explanations, comments and notes.',
+      },
       { role: 'system', content: 'Separate each item in the list by a ;' },
     ];
-    const resolvedHistory = history ? 
-      includeSystemMessages ?
-        history.push(systemMessages)
-        :
-        history
-      :
-      includeSystemMessages ?
-        new MessageHistory().push(systemMessages)
-        :
-        undefined
-    ;
+    const resolvedHistory = history
+      ? includeSystemMessages
+        ? history.push(systemMessages)
+        : history
+      : includeSystemMessages
+        ? new MessageHistory().push(systemMessages)
+        : undefined;
     const list = await this.generateResponse(messages, model, resolvedHistory, functions, messageModerators, logLevel);
-    return list.split(';').map(item => item.trim());
+    return list.split(';').map((item) => item.trim());
   }
-}
+}

package/src/Paragraph.ts

@@ -9,9 +9,10 @@ export class Paragraph {
   }
 
   toString(): string {
-    if (this.sentences.length == 0)
+    if (this.sentences.length == 0) {
       return '';
+    }
 
     return this.sentences.join(' ');
   }
-}
+}

package/src/Sentence.ts

@@ -8,13 +8,15 @@ export class Sentence {
   }
 
   toString(): string {
-    if (this.lines.length == 0)
+    if (this.lines.length == 0) {
       return '';
+    }
 
     let sentence = this.lines.join(', ');
-    if (sentence.lastIndexOf('.') != (sentence.length - 1))
+    if (sentence.lastIndexOf('.') != sentence.length - 1) {
       sentence += '.';
+    }
 
     return sentence;
   }
-}
+}

package/src/code_template/Code.ts

@@ -3,21 +3,21 @@ import { Conversation } from '../Conversation';
 import { Repo } from './Repo';
 
 export type SourceFile = {
-  relativePath: string,
-  code: Code
-}
+  relativePath: string;
+  code: Code;
+};
 
-export type Import = { 
-  moduleNames: string[], 
-  importPathFromGeneratedFile: string, 
-  sourceFilePath: string,
-}
+export type Import = {
+  moduleNames: string[];
+  importPathFromGeneratedFile: string;
+  sourceFilePath: string;
+};
 
 export type CodeArgs = {
-  conversation: Conversation,
-  description: string[],
-  imports?: Import[],
-}
+  conversation: Conversation;
+  description: string[];
+  imports?: Import[];
+};
 
 export class Code {
   private args: CodeArgs;
@@ -27,27 +27,33 @@ export class Code {
   }
 
   async generate(): Promise<string> {
-    if (this.args.imports)
+    if (this.args.imports) {
       this.addImports(this.args.imports, this.args.conversation);
-    
-      return await this.args.conversation.generateCode(this.args.description, 'gpt-4');
+    }
+
+    return await this.args.conversation.generateCode(this.args.description, 'gpt-4');
   }
 
   private addImports(imports: Import[], conversation: Conversation) {
     conversation.addSystemMessagesToHistory([
-      this.declarationMessage(imports.map(d => d.sourceFilePath)),
+      this.declarationMessage(imports.map((d) => d.sourceFilePath)),
       this.importMessage(imports),
     ]);
   }
 
   private declarationMessage(tsFilePaths: string[]) {
-    const declarationMap = PackageUtil.generateTypescriptDeclarations({ tsFilePaths, includeDependencyDeclarations: true });
+    const declarationMap = PackageUtil.generateTypescriptDeclarations({
+      tsFilePaths,
+      includeDependencyDeclarations: true,
+    });
     const declarations = Object.values(declarationMap).join('\n');
     return `Assume the following code exists in other files:\n${declarations}`;
   }
 
   private importMessage(imports: Omit<Import, 'filePath'>[]) {
-    const importStatements = imports.map(i => `import { ${i.moduleNames.join(', ')} } from '${i.importPathFromGeneratedFile}'`);
+    const importStatements = imports.map(
+      (i) => `import { ${i.moduleNames.join(', ')} } from '${i.importPathFromGeneratedFile}'`
+    );
     return `Add the following imports:\n${importStatements}`;
   }
-}
+}

package/src/code_template/CodeTemplate.ts

@@ -3,10 +3,10 @@ import { Fs, PackageUtil, Package } from '@proteinjs/util-node';
 import { SourceFile } from './Code';
 
 export type TemplateArgs = {
-  srcPath: string,
-  additionalPackages?: Package[],
-  replacePackages?: boolean,
-}
+  srcPath: string;
+  additionalPackages?: Package[];
+  replacePackages?: boolean;
+};
 
 export abstract class CodeTemplate {
   protected logger = new Logger(this.constructor.name);
@@ -21,7 +21,7 @@ export abstract class CodeTemplate {
 
   async generate() {
     await PackageUtil.installPackages(this.resolvePackages());
-    for (let sourceFile of this.sourceFiles()) {
+    for (const sourceFile of this.sourceFiles()) {
       const filePath = Fs.baseContainedJoin(this.templateArgs.srcPath, sourceFile.relativePath);
       this.logger.info(`Generating source file: ${filePath}`);
       const code = await sourceFile.code.generate();
@@ -32,8 +32,9 @@ export abstract class CodeTemplate {
 
   private resolvePackages() {
     const packages: Package[] = this.templateArgs.replacePackages ? [] : this.dependencyPackages();
-    if (this.templateArgs.additionalPackages)
+    if (this.templateArgs.additionalPackages) {
       packages.push(...this.templateArgs.additionalPackages);
+    }
     return packages;
   }
-}
+}

package/src/code_template/CodeTemplateModule.ts

@@ -8,7 +8,7 @@ export class CodeTemplateModule implements ConversationModule {
   getName(): string {
     return 'Code Template';
   }
-  
+
   getSystemMessages(): string[] {
     return [
       `If they want to create a function/class/object using an API we are familiar with, we will ask the user for the required information to fill in all mandatory parameters and ask them if they want to provide optional parameter values`,
@@ -47,4 +47,4 @@ export class CodeTemplateModule implements ConversationModule {
 //   await cmd(command, args, {OPENAI_API_KEY: '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'});
 //   console.info(`Ran command: ${commandLog}`);
 //   console.info(`Generated code from template: ${codePath}`);
-// }
+// }

package/src/code_template/Repo.ts

@@ -8,20 +8,20 @@ export interface TsFile extends FileDescriptor {
 }
 
 export interface PackageInfo {
-  packageJSON: any;  // The content of the package.json
+  packageJSON: any; // The content of the package.json
   dirPath: string;
   tsFiles: { [tsFilePath: string]: TsFile };
   fileDescriptors: FileDescriptor[];
 }
 
-export type SlimPackageInfo = Omit<PackageInfo, 'packageJSON'|'tsFiles'>;
+export type SlimPackageInfo = Omit<PackageInfo, 'packageJSON' | 'tsFiles'>;
 
 export type RepoParams = {
-  packages: Record<string, PackageInfo>,
-  slimPackages: Record<string, SlimPackageInfo>,
-  tsFiles: { [tsFilePath: string]: TsFile },
-  keywordFilesIndex: { [keyword: string]: string[] /** file paths */ },
-}
+  packages: Record<string, PackageInfo>;
+  slimPackages: Record<string, SlimPackageInfo>;
+  tsFiles: { [tsFilePath: string]: TsFile };
+  keywordFilesIndex: { [keyword: string]: string[] /** file paths */ };
+};
 
 export class Repo {
   private logger = new Logger(this.constructor.name);
@@ -55,7 +55,7 @@ export class Repo {
 
   getDeclarations(params: { tsFilePaths: string[] }) {
     const queriedDeclarations: { [tsFilePath: string]: string } = {};
-    for (let tsFilePath of params.tsFilePaths) {
+    for (const tsFilePath of params.tsFilePaths) {
       queriedDeclarations[tsFilePath] = this.params.tsFiles[tsFilePath].declaration;
       this.logger.info(`Accessed declaration: ${tsFilePath}`);
     }
@@ -68,25 +68,26 @@ export class RepoFactory {
 
   public static async createRepo(dir: string): Promise<Repo> {
     this.LOGGER.info(`Creating repo for dir: ${dir}`);
-    let repoParams: RepoParams = { packages: {}, slimPackages: {}, tsFiles: {}, keywordFilesIndex: {} };
+    const repoParams: RepoParams = { packages: {}, slimPackages: {}, tsFiles: {}, keywordFilesIndex: {} };
 
     async function traverse(dir: string) {
       const childrenNames = await fs.readdir(dir, { withFileTypes: true });
-      let hasPackageJson = childrenNames.some(dirent => dirent.name === 'package.json');
+      const hasPackageJson = childrenNames.some((dirent) => dirent.name === 'package.json');
       if (hasPackageJson) {
         const packageContent = await fs.readFile(path.join(dir, 'package.json'), 'utf-8');
         const packageJSON = JSON.parse(packageContent);
-        repoParams.packages[packageJSON.name] = { 
+        repoParams.packages[packageJSON.name] = {
           packageJSON: packageJSON,
           dirPath: dir,
           fileDescriptors: [],
           tsFiles: {},
         };
       }
-      
+
       for (const dirent of childrenNames) {
-        if (!dirent.isDirectory())
+        if (!dirent.isDirectory()) {
           continue;
+        }
 
         // Exclude directories 'node_modules' and 'dist' right at the beginning
         if (dirent.name.includes('node_modules') || dirent.name.includes('dist')) {
@@ -101,7 +102,7 @@ export class RepoFactory {
 
     await traverse(dir);
     await RepoFactory.loadFiles(repoParams);
-    Object.keys(repoParams.packages).forEach(packageName => {
+    Object.keys(repoParams.packages).forEach((packageName) => {
       const { packageJSON, tsFiles, ...slimPackage } = repoParams.packages[packageName];
       repoParams.slimPackages[packageName] = slimPackage;
     });
@@ -110,18 +111,23 @@ export class RepoFactory {
   }
 
   private static async loadFiles(repoParams: RepoParams) {
-    for (let packageName of Object.keys(repoParams.packages)) {
+    for (const packageName of Object.keys(repoParams.packages)) {
       this.LOGGER.info(`Loading files for package: ${packageName}`);
       const dirPath = repoParams.packages[packageName].dirPath;
       if (dirPath) {
-        repoParams.packages[packageName].fileDescriptors.push(...await Fs.getFilesInDirectory(dirPath, ['node_modules', 'dist']));
-        for (let fileDescriptor of repoParams.packages[packageName].fileDescriptors) {
-          const typescriptDeclaration = PackageUtil.generateTypescriptDeclarations({ tsFilePaths: [fileDescriptor.path] })[fileDescriptor.path];
+        repoParams.packages[packageName].fileDescriptors.push(
+          ...(await Fs.getFilesInDirectory(dirPath, ['node_modules', 'dist']))
+        );
+        for (const fileDescriptor of repoParams.packages[packageName].fileDescriptors) {
+          const typescriptDeclaration = PackageUtil.generateTypescriptDeclarations({
+            tsFilePaths: [fileDescriptor.path],
+          })[fileDescriptor.path];
           const tsFile = Object.assign({ declaration: typescriptDeclaration }, fileDescriptor);
           repoParams.packages[packageName].tsFiles[fileDescriptor.path] = tsFile;
           repoParams.tsFiles[fileDescriptor.path] = tsFile;
-          if (!repoParams.keywordFilesIndex[fileDescriptor.nameWithoutExtension])
+          if (!repoParams.keywordFilesIndex[fileDescriptor.nameWithoutExtension]) {
             repoParams.keywordFilesIndex[fileDescriptor.nameWithoutExtension] = [];
+          }
 
           repoParams.keywordFilesIndex[fileDescriptor.nameWithoutExtension].push(fileDescriptor.path);
         }