@proteinjs/conversation 1.0.5 → 1.0.7

package/src/fs/conversation_fs/ConversationFsModerator.ts

@@ -1,3 +1,4 @@
+/* eslint-disable no-empty */
 import { LogLevel, Logger } from '@proteinjs/util';
 import { FileContentMap } from '@proteinjs/util-node';
 import { ChatCompletionMessageParam } from 'openai/resources/chat';
@@ -23,12 +24,12 @@ export class ConversationFsFactory {
   }
 
   merge(existingFs: ConversationFs, updates: FileContentMap): ConversationFs {
-    for (let filePath of Object.keys(updates)) {
+    for (const filePath of Object.keys(updates)) {
       // if the file already exists in the fs
       if (existingFs.fileContentMap[filePath]) {
-        this.logger.debug(`Updating existing file: ${filePath}`)
+        this.logger.debug(`Updating existing file: ${filePath}`);
         existingFs.fileContentMap[filePath] = updates[filePath];
-        const oldIndex = existingFs.order.findIndex(item => item == filePath);
+        const oldIndex = existingFs.order.findIndex((item) => item == filePath);
         existingFs.order.splice(oldIndex, 1);
         existingFs.order.push(filePath);
         continue;
@@ -36,12 +37,12 @@ export class ConversationFsFactory {
 
       // if we have less than the max number of files in the fs
       if (Object.keys(existingFs.fileContentMap).length < this.params.maxFiles) {
-        this.logger.debug(`Adding new file (under limit): ${filePath}`)
+        this.logger.debug(`Adding new file (under limit): ${filePath}`);
         existingFs.fileContentMap[filePath] = updates[filePath];
         existingFs.order.push(filePath);
         continue;
       } else {
-        this.logger.debug(`Adding new file (over limit): ${filePath}`)
+        this.logger.debug(`Adding new file (over limit): ${filePath}`);
         const removedFilePath = existingFs.order.splice(0, 1)[0];
         delete existingFs.fileContentMap[removedFilePath];
         existingFs.fileContentMap[filePath] = updates[filePath];
@@ -57,15 +58,16 @@ export class ConversationFsModerator implements MessageModerator {
   private logLevel: LogLevel = 'info';
 
   constructor(logLevel?: LogLevel) {
-    if (logLevel)
+    if (logLevel) {
       this.logLevel = logLevel;
+    }
   }
 
   observe(messages: ChatCompletionMessageParam[]): ChatCompletionMessageParam[] {
     let conversationFileSystemMessageIndex: number = -1;
-    let conversationFileSystem: ConversationFs|undefined;
-    let readFilesFunctionCallMessageIndexes: number[] = [];
-    let writeFilesFunctionCallMessageIndexes: number[] = [];
+    let conversationFileSystem: ConversationFs | undefined;
+    const readFilesFunctionCallMessageIndexes: number[] = [];
+    const writeFilesFunctionCallMessageIndexes: number[] = [];
     const readFilesConsolidatedOutput: FileContentMap = {}; // newest version of file wins
     for (let i = 0; i < messages.length; i++) {
       const message = messages[i];
@@ -74,8 +76,9 @@ export class ConversationFsModerator implements MessageModerator {
         try {
           parsedContent = JSON.parse(message.content);
         } catch (error) {}
-        if (!parsedContent || !parsedContent['fileSystem'])
+        if (!parsedContent || !parsedContent['fileSystem']) {
           continue;
+        }
 
         conversationFileSystem = parsedContent['fileSystem'];
         conversationFileSystemMessageIndex = i;
@@ -83,14 +86,15 @@ export class ConversationFsModerator implements MessageModerator {
       }
 
       if (message.role == 'function' && message.name == 'readFiles' && message.content) {
-        let parsedContent: any|undefined;
+        let parsedContent: any | undefined;
         try {
           parsedContent = JSON.parse(message.content);
         } catch (error) {}
-        if (!parsedContent)
+        if (!parsedContent) {
           continue;
+        }
 
-        for (let filePath of Object.keys(parsedContent)) {
+        for (const filePath of Object.keys(parsedContent)) {
           readFilesConsolidatedOutput[filePath] = parsedContent[filePath];
         }
 
@@ -103,19 +107,29 @@ export class ConversationFsModerator implements MessageModerator {
     }
 
     if (conversationFileSystem) {
-      conversationFileSystem = new ConversationFsFactory({ logLevel: this.logLevel }).merge(conversationFileSystem, readFilesConsolidatedOutput);
+      conversationFileSystem = new ConversationFsFactory({ logLevel: this.logLevel }).merge(
+        conversationFileSystem,
+        readFilesConsolidatedOutput
+      );
       const content = JSON.stringify({ fileSystem: conversationFileSystem });
       messages[conversationFileSystemMessageIndex].content = content;
     } else {
-      conversationFileSystem = { fileContentMap: readFilesConsolidatedOutput, order: Object.keys(readFilesConsolidatedOutput) };
-      messages.push({ role: 'system', content: `Whenever you make a call to readFiles, the file content will be loaded into the { fileSystem } object in the message history. Do not respond with fileSystem's content in a message.` });
+      conversationFileSystem = {
+        fileContentMap: readFilesConsolidatedOutput,
+        order: Object.keys(readFilesConsolidatedOutput),
+      };
+      messages.push({
+        role: 'system',
+        content: `Whenever you make a call to readFiles, the file content will be loaded into the { fileSystem } object in the message history. Do not respond with fileSystem's content in a message.`,
+      });
       const content = JSON.stringify({ fileSystem: conversationFileSystem });
       messages.push({ role: 'system', content });
     }
 
-    const moderatedMessages = messages
-      .filter((message, i) => !readFilesFunctionCallMessageIndexes.includes(i) && !writeFilesFunctionCallMessageIndexes.includes(i))
-    ;
+    const moderatedMessages = messages.filter(
+      (message, i) =>
+        !readFilesFunctionCallMessageIndexes.includes(i) && !writeFilesFunctionCallMessageIndexes.includes(i)
+    );
     return moderatedMessages;
   }
-}
+}

package/src/fs/conversation_fs/ConversationFsModule.ts

@@ -3,7 +3,15 @@ import { Function } from '../../Function';
 import { searchFilesFunctionName } from '../keyword_to_files_index/KeywordToFilesIndexFunctions';
 import { searchLibrariesFunctionName, searchPackagesFunctionName } from '../package/PackageFunctions';
 import { ConversationFsModerator } from './ConversationFsModerator';
-import { fsFunctions, getRecentlyAccessedFilePathsFunction, getRecentlyAccessedFilePathsFunctionName, readFilesFunction, readFilesFunctionName, writeFilesFunction, writeFilesFunctionName } from './FsFunctions';
+import {
+  fsFunctions,
+  getRecentlyAccessedFilePathsFunction,
+  getRecentlyAccessedFilePathsFunctionName,
+  readFilesFunction,
+  readFilesFunctionName,
+  writeFilesFunction,
+  writeFilesFunctionName,
+} from './FsFunctions';
 
 export class ConversationFsModule implements ConversationModule {
   private repoPath: string;
@@ -16,7 +24,7 @@ export class ConversationFsModule implements ConversationModule {
   getName(): string {
     return 'Conversation Fs';
   }
-  
+
   getSystemMessages(): string[] {
     return [
       `Assume the current working directory is: ${this.repoPath} unless specified by the user`,
@@ -38,14 +46,12 @@ export class ConversationFsModule implements ConversationModule {
       readFilesFunction(this),
       writeFilesFunction(this),
       getRecentlyAccessedFilePathsFunction(this),
-      ...fsFunctions
+      ...fsFunctions,
     ];
   }
 
   getMessageModerators() {
-    return [
-      new ConversationFsModerator(),
-    ];
+    return [new ConversationFsModerator()];
   }
 
   pushRecentlyAccessedFilePath(filePaths: string[]) {
@@ -61,4 +67,4 @@ export class ConversationFsModuleFactory implements ConversationModuleFactory {
   async createModule(repoPath: string): Promise<ConversationFsModule> {
     return new ConversationFsModule(repoPath);
   }
-}
+}

package/src/fs/conversation_fs/FsFunctions.ts

@@ -19,17 +19,15 @@ export function readFilesFunction(fsModule: ConversationFsModule) {
             },
           },
         },
-        required: ['filePaths']
+        required: ['filePaths'],
       },
     },
     call: async (params: { filePaths: string[] }) => {
       fsModule.pushRecentlyAccessedFilePath(params.filePaths);
       return await Fs.readFiles(params.filePaths);
     },
-    instructions: [
-      `To read files from the local file system, use the ${readFilesFunctionName} function`,
-    ],
-  }
+    instructions: [`To read files from the local file system, use the ${readFilesFunctionName} function`],
+  };
 }
 
 export const writeFilesFunctionName = 'writeFiles';
@@ -59,17 +57,15 @@ export function writeFilesFunction(fsModule: ConversationFsModule) {
             },
           },
         },
-        required: ['files']
+        required: ['files'],
       },
     },
     call: async (params: { files: File[] }) => {
-      fsModule.pushRecentlyAccessedFilePath(params.files.map(file => file.path));
+      fsModule.pushRecentlyAccessedFilePath(params.files.map((file) => file.path));
       return await Fs.writeFiles(params.files);
     },
-    instructions: [
-      `To write files to the local file system, use the ${writeFilesFunctionName} function`,
-    ],
-  }
+    instructions: [`To write files to the local file system, use the ${writeFilesFunctionName} function`],
+  };
 }
 
 export const getRecentlyAccessedFilePathsFunctionName = 'getRecentlyAccessedFilePaths';
@@ -85,7 +81,7 @@ export function getRecentlyAccessedFilePathsFunction(fsModule: ConversationFsMod
       },
     },
     call: async () => fsModule.getRecentlyAccessedFilePaths(),
-  }
+  };
 }
 
 const createFolderFunctionName = 'createFolder';
@@ -101,14 +97,12 @@ const createFolderFunction: Function = {
           description: 'Path of the new directory',
         },
       },
-      required: ['path']
+      required: ['path'],
     },
   },
   call: async (params: { path: string }) => await Fs.createFolder(params.path),
-  instructions: [
-    `To create a folder on the local file system, use the ${createFolderFunctionName} function`,
-  ],
-}
+  instructions: [`To create a folder on the local file system, use the ${createFolderFunctionName} function`],
+};
 
 export const fileOrDirectoryExistsFunctionName = 'fileOrDirectoryExists';
 export const fileOrDirectoryExistsFunction: Function = {
@@ -123,14 +117,14 @@ export const fileOrDirectoryExistsFunction: Function = {
           description: 'Path of the file or directory',
         },
       },
-      required: ['path']
+      required: ['path'],
     },
   },
   call: async (params: { path: string }) => await Fs.exists(params.path),
   instructions: [
     `To check if a file or folder exists on the local file system, use the ${fileOrDirectoryExistsFunctionName} function`,
   ],
-}
+};
 
 export const getFilePathsMatchingGlobFunctionName = 'getFilePathsMatchingGlob';
 const getFilePathsMatchingGlobFunction: Function = {
@@ -156,14 +150,13 @@ const getFilePathsMatchingGlobFunction: Function = {
           },
         },
       },
-      required: ['dirPrefix', 'glob']
+      required: ['dirPrefix', 'glob'],
     },
   },
-  call: async (params: { dirPrefix: string, glob: string, globIgnorePatterns?: string[] }) => await Fs.getFilePathsMatchingGlob(params.dirPrefix, params.glob, params.globIgnorePatterns),
-  instructions: [
-    `To get file paths matching a glob, use the ${getFilePathsMatchingGlobFunctionName} function`,
-  ],
-}
+  call: async (params: { dirPrefix: string; glob: string; globIgnorePatterns?: string[] }) =>
+    await Fs.getFilePathsMatchingGlob(params.dirPrefix, params.glob, params.globIgnorePatterns),
+  instructions: [`To get file paths matching a glob, use the ${getFilePathsMatchingGlobFunctionName} function`],
+};
 
 export const renameFunctionName = 'renameFileOrDirectory';
 const renameFunction: Function = {
@@ -182,14 +175,12 @@ const renameFunction: Function = {
           description: 'New name for the file or directory',
         },
       },
-      required: ['oldPath', 'newName']
+      required: ['oldPath', 'newName'],
     },
   },
-  call: async (params: { oldPath: string, newName: string }) => await Fs.rename(params.oldPath, params.newName),
-  instructions: [
-    `To rename a file or directory, use the ${renameFunctionName} function`,
-  ],
-}
+  call: async (params: { oldPath: string; newName: string }) => await Fs.rename(params.oldPath, params.newName),
+  instructions: [`To rename a file or directory, use the ${renameFunctionName} function`],
+};
 
 export const copyFunctionName = 'copyFileOrDirectory';
 const copyFunction: Function = {
@@ -208,14 +199,13 @@ const copyFunction: Function = {
           description: 'Destination path for the copied file or directory',
         },
       },
-      required: ['sourcePath', 'destinationPath']
+      required: ['sourcePath', 'destinationPath'],
     },
   },
-  call: async (params: { sourcePath: string, destinationPath: string }) => await Fs.copy(params.sourcePath, params.destinationPath),
-  instructions: [
-    `To copy a file or directory, use the ${copyFunctionName} function`,
-  ],
-}
+  call: async (params: { sourcePath: string; destinationPath: string }) =>
+    await Fs.copy(params.sourcePath, params.destinationPath),
+  instructions: [`To copy a file or directory, use the ${copyFunctionName} function`],
+};
 
 export const moveFunctionName = 'moveFileOrDirectory';
 const moveFunction: Function = {
@@ -234,14 +224,13 @@ const moveFunction: Function = {
           description: 'Destination path for the moved file or directory',
         },
       },
-      required: ['sourcePath', 'destinationPath']
+      required: ['sourcePath', 'destinationPath'],
     },
   },
-  call: async (params: { sourcePath: string, destinationPath: string }) => await Fs.move(params.sourcePath, params.destinationPath),
-  instructions: [
-    `To move a file or directory, use the ${moveFunctionName} function`,
-  ],
-}
+  call: async (params: { sourcePath: string; destinationPath: string }) =>
+    await Fs.move(params.sourcePath, params.destinationPath),
+  instructions: [`To move a file or directory, use the ${moveFunctionName} function`],
+};
 
 export const fsFunctions: Function[] = [
   createFolderFunction,
@@ -250,4 +239,4 @@ export const fsFunctions: Function[] = [
   renameFunction,
   copyFunction,
   moveFunction,
-]
+];

package/src/fs/git/GitModule.ts

@@ -22,9 +22,7 @@ export class GitModule implements ConversationModule {
   }
 
   getFunctions(): Function[] {
-    return [
-      ...gitFunctions,
-    ];
+    return [...gitFunctions];
   }
 
   getMessageModerators() {
@@ -36,4 +34,4 @@ export class GitModuleFactory implements ConversationModuleFactory {
   async createModule(repoPath: string): Promise<GitModule> {
     return new GitModule(repoPath);
   }
-}
+}

package/src/fs/keyword_to_files_index/KeywordToFilesIndexFunctions.ts

@@ -1,4 +1,4 @@
-import { KeywordToFilesIndexModule } from './KeywordToFilesIndexModule'
+import { KeywordToFilesIndexModule } from './KeywordToFilesIndexModule';
 
 export const searchFilesFunctionName = 'searchFiles';
 export const searchFilesFunction = (module: KeywordToFilesIndexModule) => {
@@ -11,10 +11,10 @@ export const searchFilesFunction = (module: KeywordToFilesIndexModule) => {
         properties: {
           keyword: {
             type: 'string',
-            description: 'Search files for this keyword'
+            description: 'Search files for this keyword',
           },
         },
-        required: ['keyword']
+        required: ['keyword'],
       },
     },
     call: async (params: { keyword: string }) => module.searchFiles(params),
@@ -23,33 +23,33 @@ export const searchFilesFunction = (module: KeywordToFilesIndexModule) => {
       `Only call functions that take in filePaths with valid file paths, if you don't know the valid file path try and search for it by keyword with the ${searchFilesFunctionName} function`,
       `If the user references a file in a package without providing a path, use the ${searchFilesFunctionName} function on the keyword to find potentially relevant files, and choose the one that references the package name in its path`,
     ],
-  }
-}
+  };
+};
 
 // {
-      //   definition: {
-      //     name: 'getDeclarations',
-      //     description: 'Get the typescript declarations of files',
-      //     parameters: {
-      //       type: 'object',
-      //       properties: {
-      //         tsFilePaths: {
-      //           type: 'array',
-      //           description: 'Paths to the files',
-      //           items: {
-      //             type: 'string',
-      //           },
-      //         },
-      //         includeDependencyDeclarations: {
-      //           type: 'boolean',
-      //           description: 'if true, returns declarations for input tsFilePaths and all dependencies. defaults to false.'
-      //         },
-      //       },
-      //       required: ['tsFilePaths']
-      //     },
-      //   },
-      //   call: async (params: { tsFilePaths: string[] }) => this.repo.getDeclarations(params),
-      //   instructions: [
-      //     `Favor calling getDeclarations over readFiles if full file content is not needed`,
-      //   ],
-      // },
+//   definition: {
+//     name: 'getDeclarations',
+//     description: 'Get the typescript declarations of files',
+//     parameters: {
+//       type: 'object',
+//       properties: {
+//         tsFilePaths: {
+//           type: 'array',
+//           description: 'Paths to the files',
+//           items: {
+//             type: 'string',
+//           },
+//         },
+//         includeDependencyDeclarations: {
+//           type: 'boolean',
+//           description: 'if true, returns declarations for input tsFilePaths and all dependencies. defaults to false.'
+//         },
+//       },
+//       required: ['tsFilePaths']
+//     },
+//   },
+//   call: async (params: { tsFilePaths: string[] }) => this.repo.getDeclarations(params),
+//   instructions: [
+//     `Favor calling getDeclarations over readFiles if full file content is not needed`,
+//   ],
+// },

package/src/fs/keyword_to_files_index/KeywordToFilesIndexModule.ts

@@ -6,9 +6,9 @@ import path from 'path';
 import { searchFilesFunction, searchFilesFunctionName } from './KeywordToFilesIndexFunctions';
 
 export type KeywordToFilesIndexModuleParams = {
-  dir: string,
-  keywordFilesIndex: { [keyword: string]: string[] /** file paths */ },
-}
+  dir: string;
+  keywordFilesIndex: { [keyword: string]: string[] /** file paths */ };
+};
 
 export class KeywordToFilesIndexModule implements ConversationModule {
   private logger = new Logger(this.constructor.name);
@@ -35,9 +35,7 @@ export class KeywordToFilesIndexModule implements ConversationModule {
   }
 
   getFunctions(): Function[] {
-    return [
-      searchFilesFunction(this),
-    ];
+    return [searchFilesFunction(this)];
   }
 
   getMessageModerators() {
@@ -50,7 +48,7 @@ export class KeywordToFilesIndexModuleFactory implements ConversationModuleFacto
 
   async createModule(repoPath: string): Promise<KeywordToFilesIndexModule> {
     this.logger.debug(`Creating module for repo: ${repoPath}`);
-    let repoParams: KeywordToFilesIndexModuleParams = { keywordFilesIndex: {}, dir: repoPath };
+    const repoParams: KeywordToFilesIndexModuleParams = { keywordFilesIndex: {}, dir: repoPath };
     repoParams.keywordFilesIndex = await this.createKeywordFilesIndex(repoPath, ['**/node-typescript-parser/**']);
     this.logger.debug(`Created module for repo: ${repoPath}`);
     return new KeywordToFilesIndexModule(repoParams);
@@ -58,14 +56,17 @@ export class KeywordToFilesIndexModuleFactory implements ConversationModuleFacto
 
   /**
    * Create keyword-files index for the given base directory.
-   * 
+   *
    * @param baseDir - The directory to start the file search from.
    * @returns An index with keywords mapped to file paths.
    */
-  async createKeywordFilesIndex(baseDir: string, globIgnorePatterns: string[] = []): Promise<{ [keyword: string]: string[] }> {
+  async createKeywordFilesIndex(
+    baseDir: string,
+    globIgnorePatterns: string[] = []
+  ): Promise<{ [keyword: string]: string[] }> {
     // Ensure the base directory has a trailing slash
     if (!baseDir.endsWith(path.sep)) {
-        baseDir += path.sep;
+      baseDir += path.sep;
     }
 
     // Get all file paths, recursively, excluding node_modules and dist directories
@@ -75,14 +76,14 @@ export class KeywordToFilesIndexModuleFactory implements ConversationModuleFacto
 
     // Process each file path
     for (const filePath of filePaths) {
-        const fileName = path.parse(filePath).name; // Get file name without extension
-
-        if (!keywordFilesIndex[fileName]) {
-            keywordFilesIndex[fileName] = [];
-        }
-        
-        this.logger.debug(`fileName: ${fileName}, filePath: ${filePath}`);
-        keywordFilesIndex[fileName].push(filePath);
+      const fileName = path.parse(filePath).name; // Get file name without extension
+
+      if (!keywordFilesIndex[fileName]) {
+        keywordFilesIndex[fileName] = [];
+      }
+
+      this.logger.debug(`fileName: ${fileName}, filePath: ${filePath}`);
+      keywordFilesIndex[fileName].push(filePath);
     }
 
     return keywordFilesIndex;

package/src/fs/package/PackageFunctions.ts

@@ -39,16 +39,15 @@ export const installPackagesFunction: Function = {
         cwdPath: {
           type: 'string',
           description: 'The directory to install packages in',
-        }
+        },
       },
-      required: ['packages', 'cwdPath']
+      required: ['packages', 'cwdPath'],
     },
   },
-  call: async (params: { packages: Package[], cwdPath: string }) => await PackageUtil.installPackages(params.packages, params.cwdPath),
-  instructions: [
-    `To install a package, use the ${installPackagesFunctionName} function`,
-  ],
-}
+  call: async (params: { packages: Package[]; cwdPath: string }) =>
+    await PackageUtil.installPackages(params.packages, params.cwdPath),
+  instructions: [`To install a package, use the ${installPackagesFunctionName} function`],
+};
 
 export const runPackageScriptFunctionName = 'runPackageScript';
 const runPackageScriptFunction: Function = {
@@ -65,16 +64,17 @@ const runPackageScriptFunction: Function = {
         cwdPath: {
           type: 'string',
           description: 'If omitted, defaults to process.cwd',
-        }
+        },
       },
-      required: ['name']
+      required: ['name'],
     },
   },
-  call: async (params: { name: string, cwdPath?: string }) => await PackageUtil.runPackageScript(params.name, params.cwdPath),
+  call: async (params: { name: string; cwdPath?: string }) =>
+    await PackageUtil.runPackageScript(params.name, params.cwdPath),
   instructions: [
     `To run a npm script (such as start, test, or watch), use the ${runPackageScriptFunctionName} function`,
   ],
-}
+};
 
 export const searchPackagesFunctionName = 'searchPackages';
 export function searchPackagesFunction(packageModule: PackageModule) {
@@ -88,16 +88,14 @@ export function searchPackagesFunction(packageModule: PackageModule) {
           keyword: {
             type: 'string',
             description: 'Keyword to match package names',
-          }
+          },
         },
-        required: ['keyword']
+        required: ['keyword'],
       },
     },
     call: async (params: { keyword: string }) => await packageModule.searchPackages(params.keyword),
-    instructions: [
-      `To search for packages in the local repo, use the ${searchPackagesFunctionName} function`,
-    ],
-  }
+    instructions: [`To search for packages in the local repo, use the ${searchPackagesFunctionName} function`],
+  };
 }
 
 export const searchLibrariesFunctionName = 'searchLibraries';
@@ -112,16 +110,14 @@ export function searchLibrariesFunction(packageModule: PackageModule) {
           keyword: {
             type: 'string',
             description: 'Keyword to match file names',
-          }
+          },
         },
-        required: ['keyword']
+        required: ['keyword'],
       },
     },
     call: async (params: { keyword: string }) => await packageModule.searchLibraries(params.keyword),
-    instructions: [
-      `To search for libraries in the local repo, use the ${searchLibrariesFunctionName} function`,
-    ],
-  }
+    instructions: [`To search for libraries in the local repo, use the ${searchLibrariesFunctionName} function`],
+  };
 }
 
 export const generateTypescriptDeclarationsFunctionName = 'generateTypescriptDesclarations';
@@ -137,17 +133,17 @@ export const generateTypescriptDeclarationsFunction = {
           description: 'File paths to generate declarations for',
           items: {
             type: 'string',
-          }
-        }
+          },
+        },
       },
-      required: ['tsFilePaths']
+      required: ['tsFilePaths'],
     },
   },
   call: async (params: { tsFilePaths: string[] }) => PackageUtil.generateTypescriptDeclarations(params),
   instructions: [
     `To generate typescript declarations for a local file, use the ${generateTypescriptDeclarationsFunctionName} function`,
   ],
-}
+};
 
 export const npmInstallFunctionName = 'npmInstall';
 export const npmInstallFunction: Function = {
@@ -160,16 +156,14 @@ export const npmInstallFunction: Function = {
         cwdPath: {
           type: 'string',
           description: 'Directory to execute the command from',
-        }
+        },
       },
-      required: ['cwdPath']
+      required: ['cwdPath'],
     },
   },
   call: async (params: { cwdPath: string }) => await PackageUtil.npmInstall(params.cwdPath),
-  instructions: [
-    `To run npm install in a specific directory, use the ${npmInstallFunctionName} function`,
-  ],
-}
+  instructions: [`To run npm install in a specific directory, use the ${npmInstallFunctionName} function`],
+};
 
 export const uninstallPackagesFunctionName = 'uninstallPackages';
 export const uninstallPackagesFunction: Function = {
@@ -190,16 +184,15 @@ export const uninstallPackagesFunction: Function = {
         cwdPath: {
           type: 'string',
           description: 'The directory to uninstall packages from',
-        }
+        },
       },
-      required: ['packageNames', 'cwdPath']
+      required: ['packageNames', 'cwdPath'],
     },
   },
-  call: async (params: { packageNames: string[], cwdPath: string }) => await PackageUtil.uninstallPackages(params.packageNames, params.cwdPath),
-  instructions: [
-    `To uninstall a package, use the ${uninstallPackagesFunctionName} function`,
-  ],
-}
+  call: async (params: { packageNames: string[]; cwdPath: string }) =>
+    await PackageUtil.uninstallPackages(params.packageNames, params.cwdPath),
+  instructions: [`To uninstall a package, use the ${uninstallPackagesFunctionName} function`],
+};
 
 export const packageFunctions: Function[] = [
   installPackagesFunction,
@@ -207,4 +200,4 @@ export const packageFunctions: Function[] = [
   generateTypescriptDeclarationsFunction,
   npmInstallFunction,
   uninstallPackagesFunction,
-]
+];