@proteinjs/conversation 1.0.1

package/src/CodegenConversation.ts

@@ -0,0 +1,92 @@
+import * as readline from 'readline-sync';
+import { Conversation } from './Conversation';
+import { KeywordToFilesIndexModuleFactory } from './fs/keyword_to_files_index/KeywordToFilesIndexModule';
+import { ConversationTemplateModuleFactory } from './template/ConversationTemplateModule';
+import { ConversationFsModuleFactory } from './fs/conversation_fs/ConversationFsModule';
+import { PackageModuleFactory } from './fs/package/PackageModule';
+import { ConversationModule, ConversationModuleFactory } from './ConversationModule';
+import { Reset, textColorMap } from '@proteinjs/util';
+import { GitModuleFactory } from './fs/git/GitModule';
+import { TiktokenModel } from 'tiktoken';
+import { searchLibrariesFunctionName, searchPackagesFunctionName } from './fs/package/PackageFunctions';
+import { getRecentlyAccessedFilePathsFunctionName, readFilesFunctionName } from './fs/conversation_fs/FsFunctions';
+import { searchFilesFunctionName } from './fs/keyword_to_files_index/KeywordToFilesIndexFunctions';
+
+export class CodegenConversation {
+  private static INITIAL_QUESTION = 'What would you like to create?';
+  private static BOT_NAME = 'Alina';
+  private static MODEL: TiktokenModel = 'gpt-4'; //'gpt-3.5-turbo-16k';
+  private repoPath: string;
+
+  constructor(repoPath: string) {
+    this.repoPath = repoPath;
+  }
+
+  async start() {
+    const conversation = await this.createConversation();
+    conversation.addAssistantMessagesToHistory([CodegenConversation.INITIAL_QUESTION]);
+    const initialUserInput = this.respondToUser(CodegenConversation.INITIAL_QUESTION);
+    let response = await conversation.generateResponse([initialUserInput], CodegenConversation.MODEL);
+    while (true) {
+      const userInput = this.respondToUser(response);
+      response = await conversation.generateResponse([userInput], CodegenConversation.MODEL);
+    }
+  }
+
+  private async createConversation() {
+    const conversation = new Conversation({
+      name: this.constructor.name,
+      modules: await this.getModules(),
+      logLevel: 'info',
+    });
+    conversation.addSystemMessagesToHistory(this.getSystemMessages());
+    return conversation;
+  }
+
+  private async getModules(): Promise<ConversationModule[]> {
+    const moduleFactories: ConversationModuleFactory[] = [
+      new ConversationFsModuleFactory(),
+      new KeywordToFilesIndexModuleFactory(),
+      new PackageModuleFactory(),
+      new ConversationTemplateModuleFactory(),
+      new GitModuleFactory(),
+    ];
+    const modules: ConversationModule[] = [];
+    for (let moduleFactory of moduleFactories)
+      modules.push(await moduleFactory.createModule(this.repoPath));
+
+    return modules;
+  }
+
+  private getSystemMessages() {
+    return [
+      `We are going to have a conversation with the user to generate code`,
+      `Await all function calls that return a promise`,
+      `Try to repspond to the user with as few words as possible while still having a conversational tone`,
+      `When generating code, export the objects you create inline; do not use 'export default' syntax`,
+      // `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`,
+      // `If a conversation summary exists, if you aren't already working with a file, use the most relevant keyword mentioned in the conversation summary to find a file to read (using the ${searchFilesFunctionName} function) and then respond to the user after reading the file`,
+      // `Use the most relevant keyword mentioned in the conversation summary to find a file to read (using the ${searchFilesFunctionName} function) and then respond to the user after reading the file`,
+      // `If the conversation summary indicates the user was working with a file get the file path (use the ${searchFilesFunctionName} function if needed) and read the file with the ${readFilesFunctionName} function. Use that file as context to respond to the user.`,
+      //
+      // `Use the conversation summary to identify a file as context for the user interaction`,
+      // `Use the ${searchFilesFunctionName} function to find the file if needed; read the file if needed`,
+      // `If the user is referring to a function, object, class, or type and you don't have the relevant file content, first inspect the conversation summary in the chat history (if it exists) to find a file name, and call the ${searchFilesFunctionName} function and read the file before responding to the user`,
+      // `Before calling ${searchFilesFunctionName}, ${searchLibrariesFunctionName} or ${searchPackagesFunctionName}, use the conversation summary in the chat history to identify a file or keyword to search for instead; after reading that file, respond to the user's request`,
+      // 
+      // `Use the ${getRecentlyAccessedFilePathsFunctionName} function find a file that might pertain to the user's request before searching files, libraries or packages; read that file then respond to the user`,
+      // `When trying to locate code, use the ${getRecentlyAccessedFilePathsFunctionName} function to search recently accessed files first, then proceed to calling other functions: ${searchLibrariesFunctionName}, ${searchPackagesFunctionName}, ${searchFilesFunctionName}`,
+      // `The conversation summary indicates files recently worked in as well`,
+      // `If that doesn't yield results, proceed to calling the ${searchLibrariesFunctionName} function, then fall back to functions: ${searchPackagesFunctionName}, ${searchFilesFunctionName}`,
+      // 
+      // `To find code, a file, or a library, call ${getRecentlyAccessedFilePathsFunctionName} and read the most recent file, after trying that call ${searchLibrariesFunctionName} then ${searchFilesFunctionName} to find a relevant file`,
+      // `The file mentioned in the conversation summary should be read if we're not already working in a file`,
+      // `If there is a conversation summary assistant message, use that to pick a file to read before responding to the user if not already working with a specific file`,
+      // `Check for a previous conversation summary assistant message in the chat history; if there is one and it mentions a file the user was working with, call ${searchLibrariesFunctionName} to find the file path then call ${readFilesFunctionName} to read the file. Do this to build context before responding to the user`,
+    ];
+  }
+
+  private respondToUser(message: string) {
+    return readline.question(`${textColorMap.cyan}[${CodegenConversation.BOT_NAME}] ${message}${Reset}\n`);
+  }
+}

package/src/Conversation.ts

@@ -0,0 +1,207 @@
+import { ChatCompletionMessageParam } from 'openai/resources/chat';
+import { DEFAULT_MODEL, OpenAi } from './OpenAi';
+import { MessageHistory } from './history/MessageHistory';
+import { Function } from './Function';
+import { Logger, LogLevel } from '@proteinjs/util';
+import { Fs } from '@proteinjs/util-node';
+import { MessageModerator } from './history/MessageModerator';
+import { ConversationModule } from './ConversationModule';
+import { TiktokenModel, encoding_for_model } from 'tiktoken';
+import { searchLibrariesFunctionName } from './fs/package/PackageFunctions';
+
+export type ConversationParams = {
+  name: string,
+  modules?: ConversationModule[];
+  logLevel?: LogLevel;
+  limits?: {
+    enforceLimits?: boolean;
+    maxMessagesInHistory?: number;
+    tokenLimit?: number;
+  };
+}
+
+export class Conversation {
+  private tokenLimit = 3000;
+  private history;
+  private systemMessages: ChatCompletionMessageParam[] = [];
+  private functions: Function[] = [];
+  private messageModerators: MessageModerator[] = [];
+  private generatedCode = false;
+  private generatedList = false;
+  private logger: Logger;
+  private params: ConversationParams;
+
+  constructor(params: ConversationParams) {
+    this.params = params;
+    this.history = new MessageHistory({ maxMessages: params.limits?.maxMessagesInHistory, enforceMessageLimit: params.limits?.enforceLimits });
+    this.logger = new Logger(params.name, params.logLevel);
+
+    if (params.modules)
+      this.addModules(params.modules);
+
+    if (typeof params.limits?.enforceLimits === 'undefined' || params.limits.enforceLimits) {
+      this.addFunctions('Conversation', [
+        summarizeConversationHistoryFunction(this),
+      ]);
+    }
+
+    if (params.limits?.tokenLimit)
+      this.tokenLimit = params.limits.tokenLimit;
+  }
+
+  private addModules(modules: ConversationModule[]) {
+    for (let module of modules) {
+      if (module.getSystemMessages().length < 1)
+        continue;
+
+      this.addSystemMessagesToHistory([
+        `The following are instructions from the ${module.getName()} module: ${module.getSystemMessages().join('. ')}`,
+      ]);
+      this.addFunctions(module.getName(), module.getFunctions());
+      this.addMessageModerators(module.getMessageModerators());
+    }
+  }
+
+  private addFunctions(moduleName: string, functions: Function[]) {
+    this.functions.push(...functions);
+    let functionInstructions = `The following are instructions from functions in the ${moduleName} module:`;
+    let functionInstructionsAdded = false;
+    for (let f of functions) {
+      if (f.instructions) {
+        if (!f.instructions || f.instructions.length < 1)
+          continue;
+
+        functionInstructionsAdded = true;
+        const instructionsParagraph = f.instructions.join('. ');
+        functionInstructions += ` ${f.definition.name}: ${instructionsParagraph}.`;
+      }
+    }
+
+    if (!functionInstructionsAdded)
+      return;
+
+    this.addSystemMessagesToHistory([functionInstructions]);
+  }
+
+  private addMessageModerators(messageModerators: MessageModerator[]) {
+    this.messageModerators.push(...messageModerators);
+  }
+
+  private async enforceTokenLimit(messages: string[], model?: TiktokenModel) {
+    if (this.params.limits?.enforceLimits === false)
+      return;
+    
+    const resolvedModel = model ? model : DEFAULT_MODEL;
+    const encoder = encoding_for_model(resolvedModel);
+    const conversation = this.history.toString() + messages.join('. ');
+    const encoded = encoder.encode(conversation);
+    console.log(`current tokens: ${encoded.length}`);
+    if (encoded.length < this.tokenLimit)
+      return;
+
+    const summarizeConversationRequest = `First, call the ${summarizeConversationHistoryFunctionName} function`;
+    await OpenAi.generateResponse([summarizeConversationRequest], model, this.history, this.functions, this.messageModerators, this.params.logLevel);
+    const referenceSummaryRequest = `If there's a file mentioned in the conversation summary, find and read the file to better respond to my next request. If that doesn't find anything, call the ${searchLibrariesFunctionName} function on other keywords in the conversation summary to find a file to read`;
+    await OpenAi.generateResponse([referenceSummaryRequest], model, this.history, this.functions, this.messageModerators, this.params.logLevel);
+  }
+
+  summarizeConversationHistory(summary: string) {
+    this.clearHistory();
+    this.history.push([{ role: 'assistant', content: `Previous conversation summary: ${summary}` }]);
+  }
+
+  private clearHistory() {
+    this.history = new MessageHistory();
+    this.history.push(this.systemMessages);
+  }
+
+  addSystemMessagesToHistory(messages: string[], unshift = false) {
+    const chatCompletions: ChatCompletionMessageParam[] = messages.map(message => { return { role: 'system', content: message }});
+    if (unshift) {
+      this.history.getMessages().unshift(...chatCompletions);
+      this.history.prune();
+      this.systemMessages.unshift(...chatCompletions);
+    } else {
+      this.history.push(chatCompletions);
+      this.systemMessages.push(...chatCompletions);
+    }
+  }
+
+  addAssistantMessagesToHistory(messages: string[], unshift = false) {
+    const chatCompletions: ChatCompletionMessageParam[] = messages.map(message => { return { role: 'assistant', content: message }});
+    if (unshift) {
+      this.history.getMessages().unshift(...chatCompletions);
+      this.history.prune();
+    } else
+      this.history.push(chatCompletions);
+  }
+
+  addUserMessagesToHistory(messages: string[], unshift = false) {
+    const chatCompletions: ChatCompletionMessageParam[] = messages.map(message => { return { role: 'user', content: message }});
+    if (unshift) {
+      this.history.getMessages().unshift(...chatCompletions);
+      this.history.prune();
+    } else
+      this.history.push(chatCompletions);
+  }
+
+  async generateResponse(messages: string[], model?: TiktokenModel) {
+    await this.enforceTokenLimit(messages, model);
+    return await OpenAi.generateResponse(messages, model, this.history, this.functions, this.messageModerators, this.params.logLevel);
+  }
+
+  async generateCode(description: string[], model?: TiktokenModel) {
+    this.logger.info(`Generating code for description:\n${description.join('\n')}`);
+    const code = await OpenAi.generateCode(description, model, this.history, this.functions, this.messageModerators, !this.generatedCode, this.params.logLevel);
+    this.logger.info(`Generated code:\n${code.slice(0, 150)}${code.length > 150 ? '...' : ''}`);
+    this.generatedCode = true;
+    return code;
+  }
+
+  async updateCodeFromFile(codeToUpdateFilePath: string, dependencyCodeFilePaths: string[], description: string, model?: TiktokenModel) {
+    const codeToUpdate = await Fs.readFile(codeToUpdateFilePath);
+    let dependencyDescription = `Assume the following exists:\n`;
+    for (let dependencyCodeFilePath of dependencyCodeFilePaths) {
+      const dependencCode = await Fs.readFile(dependencyCodeFilePath);
+      dependencyDescription += dependencCode + '\n\n';
+    }
+
+    this.logger.info(`Updating code from file: ${codeToUpdateFilePath}`);
+    return await this.updateCode(codeToUpdate, dependencyDescription + description, model);
+  }
+
+  async updateCode(code: string, description: string, model?: TiktokenModel) {
+    this.logger.info(`Updating code:\n${code.slice(0, 150)}${code.length > 150 ? '...' : ''}\nFrom description: ${description}`);
+    const updatedCode = await OpenAi.updateCode(code, description, model, this.history, this.functions, this.messageModerators, !this.generatedCode, this.params.logLevel);
+    this.logger.info(`Updated code:\n${updatedCode.slice(0, 150)}${updatedCode.length > 150 ? '...' : ''}`);
+    this.generatedCode = true;
+    return updatedCode;
+  }
+
+  async generateList(description: string[], model?: TiktokenModel) {
+    const list = await OpenAi.generateList(description, model, this.history, this.functions, this.messageModerators, !this.generatedList, this.params.logLevel);
+    this.generatedList = true;
+    return list;
+  }
+}
+
+export const summarizeConversationHistoryFunctionName = 'summarizeConversationHistory';
+export const summarizeConversationHistoryFunction = (conversation: Conversation) => {
+  return {
+    definition: {
+      name: summarizeConversationHistoryFunctionName,
+      description: 'Clear the conversation history and summarize what was in it',
+      parameters: {
+        type: 'object',
+        properties: {
+          summary: {
+            type: 'string',
+            description: 'A 1-3 sentence summary of the current chat history',
+          },
+        },
+        required: ['summary']
+      },
+    },
+    call: async (params: { summary: string }) => conversation.summarizeConversationHistory(params.summary),
+  }
+}

package/src/ConversationModule.ts

@@ -0,0 +1,13 @@
+import { Function } from './Function';
+import { MessageModerator } from './history/MessageModerator';
+
+export interface ConversationModule {
+  getName(): string,
+  getSystemMessages(): string[];
+  getFunctions(): Function[];
+  getMessageModerators(): MessageModerator[];
+}
+
+export interface ConversationModuleFactory {
+  createModule(repoPath: string): Promise<ConversationModule>;
+}

package/src/Function.ts

@@ -0,0 +1,8 @@
+import { ChatCompletionCreateParams } from 'openai/resources/chat';
+
+
+export interface Function {
+  definition: ChatCompletionCreateParams.Function;
+  call(obj: any): Promise<any>;
+  instructions?: string[];
+}

package/src/OpenAi.ts

@@ -0,0 +1,212 @@
+import { OpenAI as OpenAIApi } from 'openai';
+import { ChatCompletionMessage, ChatCompletionMessageParam, ChatCompletion } from 'openai/resources/chat';
+import { LogLevel, Logger } from '@proteinjs/util';
+import { MessageModerator } from './history/MessageModerator';
+import { Function } from './Function';
+import { MessageHistory } from './history/MessageHistory';
+import { TiktokenModel } from 'tiktoken';
+
+function delay(ms: number) {
+  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> {
+    const logger = new Logger('OpenAi.generateResponse', logLevel);
+    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)
+      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])
+      return await this.generateResponse([], model, messageParamsWithHistory, functions, messageModerators, logLevel);
+    }
+
+    const responseText = responseMessage.content;
+    if (!responseText) {
+      logger.error(`Received response: ${JSON.stringify(response)}`);
+      throw new Error(`Response was empty for messages: ${messages.join('\n')}`);
+    }
+
+    messageParamsWithHistory.push([responseMessage]);
+    return responseText;
+  }
+
+  private static moderateHistory(history: MessageHistory, messageModerators: MessageModerator[]) {
+    for (let 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> {
+    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)
+        logger.info(`Sending request: ${latestMessage.content}`);
+      else if (latestMessage.role == 'function')
+        logger.info(`Sending request: returning output of ${latestMessage.name} function`);
+      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),
+      });
+      const responseMessage = response.choices[0].message;
+      if (responseMessage.content)
+        logger.info(`Received response: ${responseMessage.content}`);
+      else if (responseMessage.function_call)
+        logger.info(`Received response: call ${responseMessage.function_call.name} function`);
+      else
+        logger.info(`Received response`);
+      if (response.usage)
+        logger.info(JSON.stringify(response.usage));
+      else
+        logger.info(JSON.stringify(`Usage data missing`));
+    } 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}`);
+          await delay(delayMs);
+          return await OpenAi.executeRequest(messageParamsWithHistory, logLevel, functions, model);
+        }
+      }
+
+      throw error;
+    }
+
+    return response;
+  }
+
+  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 }
+      return message;
+    }
+
+    functionCall.name = functionCall.name.split('.').pop() as string;
+    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 }
+      return message;
+    }
+
+    let returnObject = null;
+    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);
+    } catch (error: any) {
+      logger.error(error.message);
+    }
+
+    if (!returnObject)
+      return;
+
+    return {
+      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') {
+    const systemMessages: ChatCompletionMessageParam[] = [
+      { 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 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 updateCodeDescription(code: string, description: string) {
+    return `Update this code:\n\n${code}\n\n${description}`;
+  }
+
+  static parseCodeFromMarkdown(code: string) {
+    if (!code.match(/```([\s\S]+?)```/g))
+      return code;
+
+    const filteredLines: string[] = [];
+    let inCodeBlock = false;
+    for (let line of code.split('\n')) {
+      if (line.startsWith('```')) {
+        inCodeBlock = !inCodeBlock;
+        if (!inCodeBlock)
+          filteredLines.push('');
+          
+        continue;
+      }
+
+      if (inCodeBlock)
+        filteredLines.push(line);
+    }
+
+    // remove the last '' that will become a \n
+    // we only want spaces between code blocks
+    filteredLines.pop();
+
+    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[]> {
+    const systemMessages: ChatCompletionMessageParam[] = [
+      { 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 list = await this.generateResponse(messages, model, resolvedHistory, functions, messageModerators, logLevel);
+    return list.split(';').map(item => item.trim());
+  }
+}

package/src/Paragraph.ts

@@ -0,0 +1,17 @@
+import { Sentence } from './Sentence';
+
+export class Paragraph {
+  private sentences: Sentence[] = [];
+
+  add(sentence: Sentence) {
+    this.sentences.push(sentence);
+    return this;
+  }
+
+  toString(): string {
+    if (this.sentences.length == 0)
+      return '';
+
+    return this.sentences.join(' ');
+  }
+}

package/src/Sentence.ts

@@ -0,0 +1,20 @@
+// Alina was here
+export class Sentence {
+  private lines: string[] = [];
+
+  add(line: string) {
+    this.lines.push(line);
+    return this;
+  }
+
+  toString(): string {
+    if (this.lines.length == 0)
+      return '';
+
+    let sentence = this.lines.join(', ');
+    if (sentence.lastIndexOf('.') != (sentence.length - 1))
+      sentence += '.';
+
+    return sentence;
+  }
+}

package/src/code_template/Code.ts

@@ -0,0 +1,53 @@
+import { PackageUtil } from '@proteinjs/util-node';
+import { Conversation } from '../Conversation';
+import { Repo } from './Repo';
+
+export type SourceFile = {
+  relativePath: string,
+  code: Code
+}
+
+export type Import = { 
+  moduleNames: string[], 
+  importPathFromGeneratedFile: string, 
+  sourceFilePath: string,
+}
+
+export type CodeArgs = {
+  conversation: Conversation,
+  description: string[],
+  imports?: Import[],
+}
+
+export class Code {
+  private args: CodeArgs;
+
+  constructor(args: CodeArgs) {
+    this.args = args;
+  }
+
+  async generate(): Promise<string> {
+    if (this.args.imports)
+      this.addImports(this.args.imports, this.args.conversation);
+    
+      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.importMessage(imports),
+    ]);
+  }
+
+  private declarationMessage(tsFilePaths: string[]) {
+    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}'`);
+    return `Add the following imports:\n${importStatements}`;
+  }
+}

package/src/code_template/CodeTemplate.ts

@@ -0,0 +1,39 @@
+import { Logger } from '@proteinjs/util';
+import { Fs, PackageUtil, Package } from '@proteinjs/util-node';
+import { SourceFile } from './Code';
+
+export type TemplateArgs = {
+  srcPath: string,
+  additionalPackages?: Package[],
+  replacePackages?: boolean,
+}
+
+export abstract class CodeTemplate {
+  protected logger = new Logger(this.constructor.name);
+  protected templateArgs: TemplateArgs;
+
+  constructor(templateArgs: TemplateArgs) {
+    this.templateArgs = templateArgs;
+  }
+
+  abstract dependencyPackages(): Package[];
+  abstract sourceFiles(): SourceFile[];
+
+  async generate() {
+    await PackageUtil.installPackages(this.resolvePackages());
+    for (let 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();
+      await Fs.writeFiles([{ path: filePath, content: code }]);
+      this.logger.info(`Generated source file: ${filePath}`);
+    }
+  }
+
+  private resolvePackages() {
+    const packages: Package[] = this.templateArgs.replacePackages ? [] : this.dependencyPackages();
+    if (this.templateArgs.additionalPackages)
+      packages.push(...this.templateArgs.additionalPackages);
+    return packages;
+  }
+}