@proteinjs/conversation 1.0.6 → 1.0.8

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,
-]
+];

package/src/fs/package/PackageModule.ts

@@ -1,21 +1,27 @@
 import { Fs } from '@proteinjs/util-node';
 import { ConversationModule, ConversationModuleFactory } from '../../ConversationModule';
 import { Function } from '../../Function';
-import { packageFunctions, searchLibrariesFunction, searchLibrariesFunctionName, searchPackagesFunction, searchPackagesFunctionName } from './PackageFunctions';
+import {
+  packageFunctions,
+  searchLibrariesFunction,
+  searchLibrariesFunctionName,
+  searchPackagesFunction,
+  searchPackagesFunctionName,
+} from './PackageFunctions';
 import path from 'path';
 import { searchFilesFunctionName } from '../keyword_to_files_index/KeywordToFilesIndexFunctions';
 import { readFilesFunctionName } from '../conversation_fs/FsFunctions';
 
 export type Library = {
-  fileName: string,
-  filePath: string,
-  packageName: string,
-}
+  fileName: string;
+  filePath: string;
+  packageName: string;
+};
 
 export type LibraryImport = {
-  importStatements: string[],
-  typescriptDeclaration: string,
-}
+  importStatements: string[];
+  typescriptDeclaration: string;
+};
 
 export class PackageModule implements ConversationModule {
   private repoPath: string;
@@ -39,11 +45,7 @@ export class PackageModule implements ConversationModule {
   }
 
   getFunctions(): Function[] {
-    return [
-      ...packageFunctions,
-      searchPackagesFunction(this),
-      searchLibrariesFunction(this),
-    ];
+    return [...packageFunctions, searchPackagesFunction(this), searchLibrariesFunction(this)];
   }
 
   getMessageModerators() {
@@ -56,12 +58,16 @@ export class PackageModule implements ConversationModule {
    */
   async searchPackages(keyword: string): Promise<string[]> {
     const matchingPackageJsonPaths: string[] = [];
-    const packageJsonFilePaths = await Fs.getFilePathsMatchingGlob(this.repoPath, '**/package.json', ['**/node_modules/**', '**/dist/**']);
+    const packageJsonFilePaths = await Fs.getFilePathsMatchingGlob(this.repoPath, '**/package.json', [
+      '**/node_modules/**',
+      '**/dist/**',
+    ]);
     const packageJsonFileMap = await Fs.readFiles(packageJsonFilePaths);
-    for (let packageJsonFilePath of Object.keys(packageJsonFileMap)) {
+    for (const packageJsonFilePath of Object.keys(packageJsonFileMap)) {
       const packageJson = JSON.parse(packageJsonFileMap[packageJsonFilePath]);
-      if (packageJson.name.toLowerCase().includes(keyword.toLocaleLowerCase()))
+      if (packageJson.name.toLowerCase().includes(keyword.toLocaleLowerCase())) {
         matchingPackageJsonPaths.push(packageJsonFilePath);
+      }
     }
 
     return matchingPackageJsonPaths;
@@ -74,15 +80,21 @@ export class PackageModule implements ConversationModule {
    */
   async searchLibraries(keyword: string): Promise<Library[]> {
     const matchingLibraries: Library[] = [];
-    const packageJsonFilePaths = await Fs.getFilePathsMatchingGlob(this.repoPath, '**/package.json', ['**/node_modules/**', '**/dist/**']);
+    const packageJsonFilePaths = await Fs.getFilePathsMatchingGlob(this.repoPath, '**/package.json', [
+      '**/node_modules/**',
+      '**/dist/**',
+    ]);
     const packageJsonFileMap = await Fs.readFiles(packageJsonFilePaths);
-    for (let packageJsonFilePath of Object.keys(packageJsonFileMap)) {
+    for (const packageJsonFilePath of Object.keys(packageJsonFileMap)) {
       const packageJson = JSON.parse(packageJsonFileMap[packageJsonFilePath]);
       const packageJsonFilePathParts = packageJsonFilePath.split(path.sep);
       packageJsonFilePathParts.pop();
       const packageDirectory = packageJsonFilePathParts.join(path.sep);
-      const srcFilePaths = await Fs.getFilePathsMatchingGlob(path.join(packageDirectory, 'src'), '**/*.ts', ['**/node_modules/**', '**/dist/**']);
-      for (let srcFilePath of srcFilePaths) {
+      const srcFilePaths = await Fs.getFilePathsMatchingGlob(path.join(packageDirectory, 'src'), '**/*.ts', [
+        '**/node_modules/**',
+        '**/dist/**',
+      ]);
+      for (const srcFilePath of srcFilePaths) {
         const fileNameWithExtension = path.basename(srcFilePath);
         if (fileNameWithExtension.includes(keyword)) {
           const fileName = path.basename(srcFilePath, path.extname(srcFilePath));
@@ -103,4 +115,4 @@ export class PackageModuleFactory implements ConversationModuleFactory {
   async createModule(repoPath: string): Promise<PackageModule> {
     return new PackageModule(repoPath);
   }
-}
+}

package/src/history/MessageHistory.ts

@@ -20,7 +20,7 @@ export class MessageHistory {
   }
 
   toString() {
-    return this.messages.map(message => message.content).join('. ');
+    return this.messages.map((message) => message.content).join('. ');
   }
 
   setMessages(messages: ChatCompletionMessageParam[]): MessageHistory {
@@ -36,19 +36,22 @@ export class MessageHistory {
   }
 
   prune() {
-    if (this.params.enforceMessageLimit === false)
+    if (this.params.enforceMessageLimit === false) {
       return;
+    }
 
     let messageCount = 0;
     const messagesToRemoveIndexes: number[] = [];
     for (let i = this.messages.length - 1; i >= 0; i--) {
       const message = this.messages[i];
-      if (message.role == 'system')
+      if (message.role == 'system') {
         continue;
+      }
 
       messageCount++;
-      if (messageCount > this.params.maxMessages)
+      if (messageCount > this.params.maxMessages) {
         messagesToRemoveIndexes.push(i);
+      }
     }
 
     this.messages = this.messages.filter((message, i) => !messagesToRemoveIndexes.includes(i));

package/src/history/MessageModerator.ts

@@ -3,4 +3,4 @@ import { ChatCompletionMessageParam } from 'openai/resources/chat';
 export interface MessageModerator {
   // given a set of messages, modify and return
   observe(messages: ChatCompletionMessageParam[]): ChatCompletionMessageParam[];
-}
+}

package/src/template/ConversationTemplate.ts

@@ -1,12 +1,12 @@
 export type Question = {
-  text: string,
-  optional?: boolean,
-}
+  text: string;
+  optional?: boolean;
+};
 
 export type ConversationTemplate = {
-  name: string,
-  keywords: string[],
-  description: string,
-  questions: Question[],
-  instructions: () => Promise<string[]>,
-}
+  name: string;
+  keywords: string[];
+  description: string;
+  questions: Question[];
+  instructions: () => Promise<string[]>;
+};

package/src/template/ConversationTemplateFunctions.ts

@@ -14,12 +14,12 @@ export const searchConversationTemplatesFunction = (repo: ConversationTemplateMo
             description: 'Search for conversation template names that match this keyword',
           },
         },
-        required: ['keyword']
+        required: ['keyword'],
       },
     },
     call: async (params: { keyword: string }) => repo.searchConversationTemplates(params.keyword),
-  }
-}
+  };
+};
 
 export const getConversationTemplateFunctionName = 'getConversationTemplate';
 export const getConversationTemplateFunction = (repo: ConversationTemplateModule) => {
@@ -35,9 +35,10 @@ export const getConversationTemplateFunction = (repo: ConversationTemplateModule
             description: 'Get the conversation template that has this name',
           },
         },
-        required: ['conversationTemplateName']
+        required: ['conversationTemplateName'],
       },
     },
-    call: async (params: { conversationTemplateName: string }) => await repo.getConversationTemplate(params.conversationTemplateName),
-  }
-}
+    call: async (params: { conversationTemplateName: string }) =>
+      await repo.getConversationTemplate(params.conversationTemplateName),
+  };
+};

package/src/template/ConversationTemplateModule.ts

@@ -2,7 +2,12 @@ import { Logger } from '@proteinjs/util';
 import { ConversationTemplate } from './ConversationTemplate';
 import { createPackageConversationTemplate } from './createPackage/CreatePackageConversationTemplate';
 import { ConversationModule, ConversationModuleFactory } from '../ConversationModule';
-import { getConversationTemplateFunction, getConversationTemplateFunctionName, searchConversationTemplatesFunction, searchConversationTemplatesFunctionName } from './ConversationTemplateFunctions';
+import {
+  getConversationTemplateFunction,
+  getConversationTemplateFunctionName,
+  searchConversationTemplatesFunction,
+  searchConversationTemplatesFunctionName,
+} from './ConversationTemplateFunctions';
 import { createCodeConversationTemplate } from './createCode/CreateCodeConversationTemplate';
 import { createAppTemplate } from './createApp/CreateAppTemplate';
 
@@ -13,9 +18,9 @@ const conversationTemplates: ConversationTemplate[] = [
 ];
 
 export type ConversationTemplateModuleParams = {
-  conversationTemplates: { [conversationTemplateName: string]: ConversationTemplate},
-  conversationTemplateKeywordIndex: { [keyword: string]: string[] /** conversationTemplateNames */ }
-}
+  conversationTemplates: { [conversationTemplateName: string]: ConversationTemplate };
+  conversationTemplateKeywordIndex: { [keyword: string]: string[] /** conversationTemplateNames */ };
+};
 
 export class ConversationTemplateModule implements ConversationModule {
   private logger = new Logger(this.constructor.name);
@@ -35,10 +40,13 @@ export class ConversationTemplateModule implements ConversationModule {
     return conversationNames || [];
   }
 
-  async getConversationTemplate(conversationTemplateName: string): Promise<Omit<ConversationTemplate, 'instructions'> & { instructions: string[] }> {
+  async getConversationTemplate(
+    conversationTemplateName: string
+  ): Promise<Omit<ConversationTemplate, 'instructions'> & { instructions: string[] }> {
     const conversationTemplate = this.params.conversationTemplates[conversationTemplateName];
-    if (!conversationTemplate)
+    if (!conversationTemplate) {
       return {} as any;
+    }
 
     const instructions = await conversationTemplate.instructions();
     return Object.assign(conversationTemplate, { instructions });
@@ -54,10 +62,7 @@ export class ConversationTemplateModule implements ConversationModule {
   }
 
   getFunctions() {
-    return [
-      searchConversationTemplatesFunction(this),
-      getConversationTemplateFunction(this),
-    ];
+    return [searchConversationTemplatesFunction(this), getConversationTemplateFunction(this)];
   }
 
   getMessageModerators() {
@@ -67,12 +72,16 @@ export class ConversationTemplateModule implements ConversationModule {
 
 export class ConversationTemplateModuleFactory implements ConversationModuleFactory {
   async createModule(repoPath: string) {
-    const params: ConversationTemplateModuleParams = { conversationTemplates: {}, conversationTemplateKeywordIndex: {} };
-    for (let conversationTemplate of conversationTemplates) {
+    const params: ConversationTemplateModuleParams = {
+      conversationTemplates: {},
+      conversationTemplateKeywordIndex: {},
+    };
+    for (const conversationTemplate of conversationTemplates) {
       params.conversationTemplates[conversationTemplate.name] = conversationTemplate;
-      for (let keyword of conversationTemplate.keywords) {
-        if (!params.conversationTemplateKeywordIndex[keyword])
+      for (const keyword of conversationTemplate.keywords) {
+        if (!params.conversationTemplateKeywordIndex[keyword]) {
           params.conversationTemplateKeywordIndex[keyword] = [];
+        }
 
         params.conversationTemplateKeywordIndex[keyword].push(conversationTemplate.name);
       }
@@ -80,4 +89,4 @@ export class ConversationTemplateModuleFactory implements ConversationModuleFact
 
     return new ConversationTemplateModule(params);
   }
-}
+}

package/src/template/createApp/CreateAppTemplate.ts

@@ -30,4 +30,4 @@ export const createAppTemplate: ConversationTemplate = {
   description: 'This template will guide you through the process of creating a new app.',
   questions: createAppQuestions,
   instructions: createAppInstructions,
-};
+};

package/src/template/createCode/CreateCodeConversationTemplate.ts

@@ -1,17 +1,15 @@
 import { fileOrDirectoryExistsFunction, readFilesFunctionName } from '../../fs/conversation_fs/FsFunctions';
-import { generateTypescriptDeclarationsFunction, installPackagesFunction, searchLibrariesFunctionName, searchPackagesFunctionName } from '../../fs/package/PackageFunctions';
+import {
+  generateTypescriptDeclarationsFunction,
+  installPackagesFunction,
+  searchLibrariesFunctionName,
+  searchPackagesFunctionName,
+} from '../../fs/package/PackageFunctions';
 import { ConversationTemplate } from '../ConversationTemplate';
 
 export const createCodeConversationTemplate: ConversationTemplate = {
   name: 'Create code',
-  keywords: [
-    'create code',
-    'implement',
-    'write code',
-    'generate code',
-    'write software',
-    'build something',
-  ],
+  keywords: ['create code', 'implement', 'write code', 'generate code', 'write software', 'build something'],
   description: 'User and ai developing together',
   questions: [],
   instructions: async () => {
@@ -37,5 +35,5 @@ export const createCodeConversationTemplate: ConversationTemplate = {
       `3.c. When writing the code to file, if updating an existing file, be sure to read the file first to not blow away existing code. Be sure to preserve comments as well.`,
       `4. Repeat 3. unless the user asks to switch packages or files`,
     ];
-  }
-}
+  },
+};

package/src/template/createPackage/CreatePackageConversationTemplate.ts

@@ -5,14 +5,7 @@ import tConfig from './tsconfig.json';
 
 export const createPackageConversationTemplate: ConversationTemplate = {
   name: 'Create Package',
-  keywords: [
-    'package',
-    'create package',
-    'create',
-    'create a package',
-    'create a new package',
-    `new package`,
-  ],
+  keywords: ['package', 'create package', 'create', 'create a package', 'create a new package', `new package`],
   description: 'Create a npm package',
   questions: [
     { text: `Which folder should the package be created in?` },
@@ -39,4 +32,4 @@ export const createPackageConversationTemplate: ConversationTemplate = {
       `If it's a typescript project, create a tsconfig.json file in the pakage directory with the following content: ${tsConfig}`,
     ];
   },
-}
+};

package/src/template/createPackage/jest.config.js

@@ -4,6 +4,6 @@ module.exports = {
   transform: {
     '^.+\\.tsx?$': 'ts-jest',
   },
-  testMatch: ["**/?(*.)+(spec|test).ts"],
+  testMatch: ['**/?(*.)+(spec|test).ts'],
   setupFiles: ['./test/setup'],
-};
+};