@proteinjs/conversation 1.0.1

package/src/code_template/CodeTemplateModule.ts

@@ -0,0 +1,50 @@
+import { ConversationModule } from '../ConversationModule';
+import { Function } from '../Function';
+import { MessageModerator } from '../history/MessageModerator';
+
+export class CodeTemplateModule implements ConversationModule {
+  private static CODE_RESPONSE = 'Code with user input:';
+
+  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`,
+      `Once we have gotten the values for all parameters, respond with '${CodeTemplateModule.CODE_RESPONSE}' followed by the code to instantiate/call the function/class/object with the user's responses for parameter values`,
+      `If you're generating a call to a class that extends Template, require that the user provide Template's constructor parameters as well and combine them into the parameters passed into the base class you're instantiating`,
+      `Make sure you ask for a srcPath and pass that in to the Template base class constructor arg`,
+      `Surround generated code (not including imports) with a self-executing, anonymous async function like this (async function() =>{})()`,
+    ];
+  }
+  getFunctions(): Function[] {
+    return [];
+  }
+  getMessageModerators(): MessageModerator[] {
+    return [];
+  }
+}
+
+// if (response.includes(CodegenConversation.CODE_RESPONSE))
+//         await this.generateCode(response, conversation);
+
+// private async generateCode(message: string, conversation: Conversation) {
+//   const code = OpenAi.parseCodeFromMarkdown(message);
+//   const srcPathToken = 'TOKEN';
+//   const responseSrcPath = await conversation.generateResponse([`Return the srcPath the user provided surrounded by the token ${srcPathToken}`], CodegenConversation.MODEL);
+//   const srcPath = responseSrcPath.replace(/["'`]/g, '').match(/TOKEN(.*?)TOKEN/)?.[1];
+//   if (!srcPath)
+//     throw new Error(`Failed to parse responseSrcPath: ${responseSrcPath}`);
+//   const codePath = path.join(process.cwd(), srcPath, 'template.ts');
+//   await fs.ensureFile(codePath);
+//   await fs.writeFile(codePath, code);
+//   console.log(`Wrote file: ${codePath}`);
+//   const command = 'node';
+//   const args = [codePath];
+//   const commandLog = `${command} ` + args.join(' ');
+//   console.info(`Running command: ${commandLog}`);
+//   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

@@ -0,0 +1,156 @@
+import { Logger } from '@proteinjs/util';
+import { FileDescriptor, Fs, PackageUtil } from '@proteinjs/util-node';
+import fs from 'fs/promises';
+import path from 'path';
+
+export interface TsFile extends FileDescriptor {
+  declaration: string;
+}
+
+export interface PackageInfo {
+  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 RepoParams = {
+  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);
+  params: RepoParams;
+
+  constructor(params: RepoParams) {
+    this.params = params;
+  }
+
+  packages() {
+    return this.params.packages;
+  }
+
+  slimPackages() {
+    return this.params.slimPackages;
+  }
+
+  tsFiles() {
+    return this.params.tsFiles;
+  }
+
+  keywordFilesIndex() {
+    return this.params.keywordFilesIndex;
+  }
+
+  searchFiles(params: { keyword: string }) {
+    this.logger.info(`Searching for file, keyword: ${params.keyword}`);
+    const filePaths = this.keywordFilesIndex()[params.keyword];
+    return filePaths || [];
+  }
+
+  getDeclarations(params: { tsFilePaths: string[] }) {
+    const queriedDeclarations: { [tsFilePath: string]: string } = {};
+    for (let tsFilePath of params.tsFilePaths) {
+      queriedDeclarations[tsFilePath] = this.params.tsFiles[tsFilePath].declaration;
+      this.logger.info(`Accessed declaration: ${tsFilePath}`);
+    }
+    return queriedDeclarations;
+  }
+}
+
+export class RepoFactory {
+  private static LOGGER = new Logger('RepoFactory');
+
+  public static async createRepo(dir: string): Promise<Repo> {
+    this.LOGGER.info(`Creating repo for dir: ${dir}`);
+    let 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');
+      if (hasPackageJson) {
+        const packageContent = await fs.readFile(path.join(dir, 'package.json'), 'utf-8');
+        const packageJSON = JSON.parse(packageContent);
+        repoParams.packages[packageJSON.name] = { 
+          packageJSON: packageJSON,
+          dirPath: dir,
+          fileDescriptors: [],
+          tsFiles: {},
+        };
+      }
+      
+      for (const dirent of childrenNames) {
+        if (!dirent.isDirectory())
+          continue;
+
+        // Exclude directories 'node_modules' and 'dist' right at the beginning
+        if (dirent.name.includes('node_modules') || dirent.name.includes('dist')) {
+          continue;
+        }
+
+        // Continue with the traversal if it's a directory
+        const childPath = path.join(dir, dirent.name);
+        await traverse(childPath);
+      }
+    }
+
+    await traverse(dir);
+    await RepoFactory.loadFiles(repoParams);
+    Object.keys(repoParams.packages).forEach(packageName => {
+      const { packageJSON, tsFiles, ...slimPackage } = repoParams.packages[packageName];
+      repoParams.slimPackages[packageName] = slimPackage;
+    });
+    this.LOGGER.info(`Created repo for dir: ${dir}`);
+    return new Repo(repoParams);
+  }
+
+  private static async loadFiles(repoParams: RepoParams) {
+    for (let 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];
+          const tsFile = Object.assign({ declaration: typescriptDeclaration }, fileDescriptor);
+          repoParams.packages[packageName].tsFiles[fileDescriptor.path] = tsFile;
+          repoParams.tsFiles[fileDescriptor.path] = tsFile;
+          if (!repoParams.keywordFilesIndex[fileDescriptor.nameWithoutExtension])
+            repoParams.keywordFilesIndex[fileDescriptor.nameWithoutExtension] = [];
+
+          repoParams.keywordFilesIndex[fileDescriptor.nameWithoutExtension].push(fileDescriptor.path);
+        }
+      }
+    }
+  }
+
+  // private static async generateDirectoryMap(dir: string): Promise<TsFile> {
+  //   const stat = await fs.stat(dir);
+  //   let map: TsFile = {
+  //     name: path.basename(dir),
+  //     path: dir,
+  //     type: stat.isDirectory() ? 'folder' : 'file'
+  //   };
+
+  //   if (stat.isDirectory()) {
+  //     const childrenNames = await fs.readdir(dir);
+  //     map.children = await Promise.all(
+  //       childrenNames.map(child => RepoFactory.generateDirectoryMap(path.join(dir, child)))
+  //     );
+  //   } else if (dir.endsWith('.ts') || dir.endsWith('.tsx')) {
+  //     const declarations = this.generateDeclarations({ tsFilePaths: [dir] });
+  //     const declarationFilePath = path.join(path.dirname(dir), path.basename(dir, path.extname(dir))) + '.d.ts';
+  //     // console.log(`dir: ${dir}\ndeclarationFilePath: ${declarationFilePath}`);
+  //     if (declarations[declarationFilePath]) {
+  //       map.declaration = declarations[declarationFilePath];
+  //     }
+  //   }
+
+  //   return map;
+  // }
+}

package/src/fs/conversation_fs/ConversationFsModerator.ts

@@ -0,0 +1,121 @@
+import { LogLevel, Logger } from '@proteinjs/util';
+import { FileContentMap } from '@proteinjs/util-node';
+import { ChatCompletionMessageParam } from 'openai/resources/chat';
+import { MessageModerator } from '../../history/MessageModerator';
+
+export interface ConversationFs {
+  fileContentMap: FileContentMap;
+  order: string[]; // ordered list of filePaths
+}
+
+export interface ConversationFsFactoryParams {
+  maxFiles: number;
+  logLevel: LogLevel;
+}
+
+export class ConversationFsFactory {
+  private logger: Logger;
+  private params: ConversationFsFactoryParams;
+
+  constructor(params?: Partial<ConversationFsFactoryParams>) {
+    this.params = Object.assign({ maxFiles: 3, logLevel: 'info' }, params);
+    this.logger = new Logger(this.constructor.name, this.params.logLevel);
+  }
+
+  merge(existingFs: ConversationFs, updates: FileContentMap): ConversationFs {
+    for (let filePath of Object.keys(updates)) {
+      // if the file already exists in the fs
+      if (existingFs.fileContentMap[filePath]) {
+        this.logger.debug(`Updating existing file: ${filePath}`)
+        existingFs.fileContentMap[filePath] = updates[filePath];
+        const oldIndex = existingFs.order.findIndex(item => item == filePath);
+        existingFs.order.splice(oldIndex, 1);
+        existingFs.order.push(filePath);
+        continue;
+      }
+
+      // 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}`)
+        existingFs.fileContentMap[filePath] = updates[filePath];
+        existingFs.order.push(filePath);
+        continue;
+      } else {
+        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];
+        existingFs.order.push(filePath);
+      }
+    }
+
+    return existingFs;
+  }
+}
+
+export class ConversationFsModerator implements MessageModerator {
+  private logLevel: LogLevel = 'info';
+
+  constructor(logLevel?: LogLevel) {
+    if (logLevel)
+      this.logLevel = logLevel;
+  }
+
+  observe(messages: ChatCompletionMessageParam[]): ChatCompletionMessageParam[] {
+    let conversationFileSystemMessageIndex: number = -1;
+    let conversationFileSystem: ConversationFs|undefined;
+    let readFilesFunctionCallMessageIndexes: number[] = [];
+    let writeFilesFunctionCallMessageIndexes: number[] = [];
+    const readFilesConsolidatedOutput: FileContentMap = {}; // newest version of file wins
+    for (let i = 0; i < messages.length; i++) {
+      const message = messages[i];
+      if (message.role == 'system' && message.content) {
+        let parsedContent: any;
+        try {
+          parsedContent = JSON.parse(message.content);
+        } catch (error) {}
+        if (!parsedContent || !parsedContent['fileSystem'])
+          continue;
+
+        conversationFileSystem = parsedContent['fileSystem'];
+        conversationFileSystemMessageIndex = i;
+        continue;
+      }
+
+      if (message.role == 'function' && message.name == 'readFiles' && message.content) {
+        let parsedContent: any|undefined;
+        try {
+          parsedContent = JSON.parse(message.content);
+        } catch (error) {}
+        if (!parsedContent)
+          continue;
+
+        for (let filePath of Object.keys(parsedContent)) {
+          readFilesConsolidatedOutput[filePath] = parsedContent[filePath];
+        }
+
+        readFilesFunctionCallMessageIndexes.push(i);
+      }
+
+      if (message.role == 'function' && message.name == 'writeFiles') {
+        writeFilesFunctionCallMessageIndexes.push(i);
+      }
+    }
+
+    if (conversationFileSystem) {
+      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.` });
+      const content = JSON.stringify({ fileSystem: conversationFileSystem });
+      messages.push({ role: 'system', content });
+    }
+
+    const moderatedMessages = messages
+      .filter((message, i) => !readFilesFunctionCallMessageIndexes.includes(i) && !writeFilesFunctionCallMessageIndexes.includes(i))
+    ;
+    return moderatedMessages;
+  }
+}

package/src/fs/conversation_fs/ConversationFsModule.ts

@@ -0,0 +1,64 @@
+import { ConversationModule, ConversationModuleFactory } from '../../ConversationModule';
+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';
+
+export class ConversationFsModule implements ConversationModule {
+  private repoPath: string;
+  private recentlyAccessedFilePaths: string[] = [];
+
+  constructor(repoPath: string) {
+    this.repoPath = repoPath;
+  }
+
+  getName(): string {
+    return 'Conversation Fs';
+  }
+  
+  getSystemMessages(): string[] {
+    return [
+      `Assume the current working directory is: ${this.repoPath} unless specified by the user`,
+      `Pre-pend the current working directory as the base path to file paths when performing file operations, unless specified otherwise by the user`,
+      `If the user asks to change the cwd, do not create a new folder, just fail if it's not a valid path`,
+      `If the user wants to work in a package, use the ${searchPackagesFunctionName} function and take the directory from the package.json file path and make that the cwd`,
+      `You have access to code in a local repo, you can read and write code to and from the file system with the ${readFilesFunctionName} function and the ${writeFilesFunctionName} function`,
+      `Before writing to a file that already exists, read the file first and make your changes to its contents`,
+      `When reading/writing a file in a specified package, join the package directory with the relative path to form the file path`,
+      `When searching for source files, do not look in the dist or node_modules directories`,
+      `If you don't know a file path, don't try to guess it, use the ${searchFilesFunctionName} function to find it`,
+      `When searching for something (ie. a file to work with/in), unless more context is specified, use the ${searchLibrariesFunctionName} function first, then fall back to functions: ${searchPackagesFunctionName}, ${searchFilesFunctionName}`,
+      `After finding a file to work with, assume the user's following question pertains to that file and use ${readFilesFunctionName} to read the file if needed`,
+    ];
+  }
+
+  getFunctions(): Function[] {
+    return [
+      readFilesFunction(this),
+      writeFilesFunction(this),
+      getRecentlyAccessedFilePathsFunction(this),
+      ...fsFunctions
+    ];
+  }
+
+  getMessageModerators() {
+    return [
+      new ConversationFsModerator(),
+    ];
+  }
+
+  pushRecentlyAccessedFilePath(filePaths: string[]) {
+    this.recentlyAccessedFilePaths.push(...filePaths);
+  }
+
+  getRecentlyAccessedFilePaths() {
+    return this.recentlyAccessedFilePaths;
+  }
+}
+
+export class ConversationFsModuleFactory implements ConversationModuleFactory {
+  async createModule(repoPath: string): Promise<ConversationFsModule> {
+    return new ConversationFsModule(repoPath);
+  }
+}

package/src/fs/conversation_fs/FsFunctions.ts

@@ -0,0 +1,253 @@
+import { File, Fs } from '@proteinjs/util-node';
+import { Function } from '../../Function';
+import { ConversationFsModule } from './ConversationFsModule';
+
+export const readFilesFunctionName = 'readFiles';
+export function readFilesFunction(fsModule: ConversationFsModule) {
+  return {
+    definition: {
+      name: readFilesFunctionName,
+      description: 'Get the content of files',
+      parameters: {
+        type: 'object',
+        properties: {
+          filePaths: {
+            type: 'array',
+            description: 'Paths to the files',
+            items: {
+              type: 'string',
+            },
+          },
+        },
+        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`,
+    ],
+  }
+}
+
+export const writeFilesFunctionName = 'writeFiles';
+export function writeFilesFunction(fsModule: ConversationFsModule) {
+  return {
+    definition: {
+      name: writeFilesFunctionName,
+      description: 'Write files to the file system',
+      parameters: {
+        type: 'object',
+        properties: {
+          files: {
+            type: 'array',
+            description: 'Files to write',
+            items: {
+              type: 'object',
+              properties: {
+                path: {
+                  type: 'string',
+                  description: 'the file path',
+                },
+                content: {
+                  type: 'string',
+                  description: 'the content to write to the file',
+                },
+              },
+            },
+          },
+        },
+        required: ['files']
+      },
+    },
+    call: async (params: { files: File[] }) => {
+      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`,
+    ],
+  }
+}
+
+export const getRecentlyAccessedFilePathsFunctionName = 'getRecentlyAccessedFilePaths';
+export function getRecentlyAccessedFilePathsFunction(fsModule: ConversationFsModule) {
+  return {
+    definition: {
+      name: getRecentlyAccessedFilePathsFunctionName,
+      description: 'Get paths of files accessed during this conversation, in order from oldest to newest',
+      parameters: {
+        type: 'object',
+        properties: {},
+        required: [],
+      },
+    },
+    call: async () => fsModule.getRecentlyAccessedFilePaths(),
+  }
+}
+
+const createFolderFunctionName = 'createFolder';
+const createFolderFunction: Function = {
+  definition: {
+    name: createFolderFunctionName,
+    description: 'Create a folder/directory',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: {
+          type: 'string',
+          description: 'Path of the new directory',
+        },
+      },
+      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`,
+  ],
+}
+
+export const fileOrDirectoryExistsFunctionName = 'fileOrDirectoryExists';
+export const fileOrDirectoryExistsFunction: Function = {
+  definition: {
+    name: fileOrDirectoryExistsFunctionName,
+    description: 'Check if a file or directory exists',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: {
+          type: 'string',
+          description: 'Path of the file or directory',
+        },
+      },
+      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 = {
+  definition: {
+    name: getFilePathsMatchingGlobFunctionName,
+    description: 'Get file paths matching a glob',
+    parameters: {
+      type: 'object',
+      properties: {
+        dirPrefix: {
+          type: 'string',
+          description: 'Directory to recursively search for files',
+        },
+        glob: {
+          type: 'string',
+          description: 'File matching pattern',
+        },
+        globIgnorePatterns: {
+          type: 'array',
+          description: 'Directories to ignore',
+          items: {
+            type: 'string',
+          },
+        },
+      },
+      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`,
+  ],
+}
+
+export const renameFunctionName = 'renameFileOrDirectory';
+const renameFunction: Function = {
+  definition: {
+    name: renameFunctionName,
+    description: 'Rename a file or directory',
+    parameters: {
+      type: 'object',
+      properties: {
+        oldPath: {
+          type: 'string',
+          description: 'Original path of the file or directory',
+        },
+        newName: {
+          type: 'string',
+          description: 'New name for the file or directory',
+        },
+      },
+      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`,
+  ],
+}
+
+export const copyFunctionName = 'copyFileOrDirectory';
+const copyFunction: Function = {
+  definition: {
+    name: copyFunctionName,
+    description: 'Copy a file or directory',
+    parameters: {
+      type: 'object',
+      properties: {
+        sourcePath: {
+          type: 'string',
+          description: 'Path of the source file or directory',
+        },
+        destinationPath: {
+          type: 'string',
+          description: 'Destination path for the copied file or directory',
+        },
+      },
+      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`,
+  ],
+}
+
+export const moveFunctionName = 'moveFileOrDirectory';
+const moveFunction: Function = {
+  definition: {
+    name: moveFunctionName,
+    description: 'Move a file or directory',
+    parameters: {
+      type: 'object',
+      properties: {
+        sourcePath: {
+          type: 'string',
+          description: 'Path of the source file or directory',
+        },
+        destinationPath: {
+          type: 'string',
+          description: 'Destination path for the moved file or directory',
+        },
+      },
+      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`,
+  ],
+}
+
+export const fsFunctions: Function[] = [
+  createFolderFunction,
+  fileOrDirectoryExistsFunction,
+  getFilePathsMatchingGlobFunction,
+  renameFunction,
+  copyFunction,
+  moveFunction,
+]

package/src/fs/git/GitModule.ts

@@ -0,0 +1,39 @@
+import { gitFunctions } from '@proteinjs/util-node';
+import { ConversationModule, ConversationModuleFactory } from '../../ConversationModule';
+import { Function } from '../../Function';
+
+export class GitModule implements ConversationModule {
+  private repoPath: string;
+
+  constructor(repoPath: string) {
+    this.repoPath = repoPath;
+  }
+
+  getName(): string {
+    return 'Git';
+  }
+
+  getSystemMessages(): string[] {
+    return [
+      `After we make code changes (write to files), ask the user if they'd like to commit and sync those changes`,
+      `If they want to commit, offer them 3 generated messages that summarize the changes to choose from, as well as the option to write a custom message`,
+      `The generated messages should be 1-3 sentences in length, and each generated option should be a different length of summary`,
+    ];
+  }
+
+  getFunctions(): Function[] {
+    return [
+      ...gitFunctions,
+    ];
+  }
+
+  getMessageModerators() {
+    return [];
+  }
+}
+
+export class GitModuleFactory implements ConversationModuleFactory {
+  async createModule(repoPath: string): Promise<GitModule> {
+    return new GitModule(repoPath);
+  }
+}