@proteinjs/conversation 1.0.6 → 1.0.8

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);
         }

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);
   }
-}
+}