@proteinjs/conversation 1.0.1

package/dist/src/fs/package/PackageModule.js

@@ -0,0 +1,102 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageModuleFactory = exports.PackageModule = void 0;
+const util_node_1 = require("@proteinjs/util-node");
+const PackageFunctions_1 = require("./PackageFunctions");
+const path_1 = __importDefault(require("path"));
+class PackageModule {
+    constructor(repoPath) {
+        this.repoPath = repoPath;
+    }
+    getName() {
+        return 'Package';
+    }
+    getSystemMessages() {
+        return [
+            `When generating code, prefer importing code from local packages`,
+            `Use the ${PackageFunctions_1.searchPackagesFunctionName} function on every package you plan to install to derermine if the package is in the local repo; if it is, calculate the relative path from the cwd package to the package being installed, use that path as the version when installing the package`,
+            // `When generating code, use the searchFiles function to find all file paths to index.ts files; these are the local apis we have access to`,
+            // `When generating import statements, use the searchFiles function to find all file paths to package.json files; if importing from a local package, make sure you import via its package if it is not a local file to the package we're generating code in`,
+            `When generating import statements from another package, do not use relative paths`,
+        ];
+    }
+    getFunctions() {
+        return [
+            ...PackageFunctions_1.packageFunctions,
+            (0, PackageFunctions_1.searchPackagesFunction)(this),
+            (0, PackageFunctions_1.searchLibrariesFunction)(this),
+        ];
+    }
+    getMessageModerators() {
+        return [];
+    }
+    /**
+     * @param keyword either the package name or some substring
+     * @return string[] of file paths
+     */
+    searchPackages(keyword) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const matchingPackageJsonPaths = [];
+            const packageJsonFilePaths = yield util_node_1.Fs.getFilePathsMatchingGlob(this.repoPath, '**/package.json', ['**/node_modules/**', '**/dist/**']);
+            const packageJsonFileMap = yield util_node_1.Fs.readFiles(packageJsonFilePaths);
+            for (let packageJsonFilePath of Object.keys(packageJsonFileMap)) {
+                const packageJson = JSON.parse(packageJsonFileMap[packageJsonFilePath]);
+                if (packageJson.name.toLowerCase().includes(keyword.toLocaleLowerCase()))
+                    matchingPackageJsonPaths.push(packageJsonFilePath);
+            }
+            return matchingPackageJsonPaths;
+        });
+    }
+    /**
+     * Search packages in repo for file names that include keyword
+     * @param keyword substring of file name to search for
+     * @returns all libraries in the repo matching the keyword
+     */
+    searchLibraries(keyword) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const matchingLibraries = [];
+            const packageJsonFilePaths = yield util_node_1.Fs.getFilePathsMatchingGlob(this.repoPath, '**/package.json', ['**/node_modules/**', '**/dist/**']);
+            const packageJsonFileMap = yield util_node_1.Fs.readFiles(packageJsonFilePaths);
+            for (let packageJsonFilePath of Object.keys(packageJsonFileMap)) {
+                const packageJson = JSON.parse(packageJsonFileMap[packageJsonFilePath]);
+                const packageJsonFilePathParts = packageJsonFilePath.split(path_1.default.sep);
+                packageJsonFilePathParts.pop();
+                const packageDirectory = packageJsonFilePathParts.join(path_1.default.sep);
+                const srcFilePaths = yield util_node_1.Fs.getFilePathsMatchingGlob(path_1.default.join(packageDirectory, 'src'), '**/*.ts', ['**/node_modules/**', '**/dist/**']);
+                for (let srcFilePath of srcFilePaths) {
+                    const fileNameWithExtension = path_1.default.basename(srcFilePath);
+                    if (fileNameWithExtension.includes(keyword)) {
+                        const fileName = path_1.default.basename(srcFilePath, path_1.default.extname(srcFilePath));
+                        matchingLibraries.push({
+                            fileName,
+                            filePath: srcFilePath,
+                            packageName: packageJson.name,
+                        });
+                    }
+                }
+            }
+            return matchingLibraries;
+        });
+    }
+}
+exports.PackageModule = PackageModule;
+class PackageModuleFactory {
+    createModule(repoPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new PackageModule(repoPath);
+        });
+    }
+}
+exports.PackageModuleFactory = PackageModuleFactory;

package/dist/src/history/MessageHistory.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageHistory = void 0;
+const util_1 = require("@proteinjs/util");
+class MessageHistory {
+    constructor(params) {
+        this.logger = new util_1.Logger(this.constructor.name);
+        this.messages = [];
+        this.params = Object.assign({ maxMessages: 20 }, params);
+    }
+    getMessages() {
+        return this.messages;
+    }
+    toString() {
+        return this.messages.map(message => message.content).join('. ');
+    }
+    setMessages(messages) {
+        this.messages = messages;
+        this.prune();
+        return this;
+    }
+    push(messages) {
+        this.messages.push(...messages);
+        this.prune();
+        return this;
+    }
+    prune() {
+        if (this.params.enforceMessageLimit === false)
+            return;
+        let messageCount = 0;
+        const messagesToRemoveIndexes = [];
+        for (let i = this.messages.length - 1; i >= 0; i--) {
+            const message = this.messages[i];
+            if (message.role == 'system')
+                continue;
+            messageCount++;
+            if (messageCount > this.params.maxMessages)
+                messagesToRemoveIndexes.push(i);
+        }
+        this.messages = this.messages.filter((message, i) => !messagesToRemoveIndexes.includes(i));
+        this.logger.debug(`Pruned ${messagesToRemoveIndexes.length} messages`);
+    }
+}
+exports.MessageHistory = MessageHistory;

package/dist/src/history/MessageModerator.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/template/ConversationTemplate.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/template/ConversationTemplateFunctions.js

@@ -0,0 +1,54 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConversationTemplateFunction = exports.getConversationTemplateFunctionName = exports.searchConversationTemplatesFunction = exports.searchConversationTemplatesFunctionName = void 0;
+exports.searchConversationTemplatesFunctionName = 'searchConversationTemplates';
+const searchConversationTemplatesFunction = (repo) => {
+    return {
+        definition: {
+            name: exports.searchConversationTemplatesFunctionName,
+            description: 'Get the conversation template names for templates matching the keyword',
+            parameters: {
+                type: 'object',
+                properties: {
+                    keyword: {
+                        type: 'string',
+                        description: 'Search for conversation template names that match this keyword',
+                    },
+                },
+                required: ['keyword']
+            },
+        },
+        call: (params) => __awaiter(void 0, void 0, void 0, function* () { return repo.searchConversationTemplates(params.keyword); }),
+    };
+};
+exports.searchConversationTemplatesFunction = searchConversationTemplatesFunction;
+exports.getConversationTemplateFunctionName = 'getConversationTemplate';
+const getConversationTemplateFunction = (repo) => {
+    return {
+        definition: {
+            name: exports.getConversationTemplateFunctionName,
+            description: 'Get the conversation template matching the name',
+            parameters: {
+                type: 'object',
+                properties: {
+                    conversationTemplateName: {
+                        type: 'string',
+                        description: 'Get the conversation template that has this name',
+                    },
+                },
+                required: ['conversationTemplateName']
+            },
+        },
+        call: (params) => __awaiter(void 0, void 0, void 0, function* () { return yield repo.getConversationTemplate(params.conversationTemplateName); }),
+    };
+};
+exports.getConversationTemplateFunction = getConversationTemplateFunction;

package/dist/src/template/ConversationTemplateModule.js

@@ -0,0 +1,80 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConversationTemplateModuleFactory = exports.ConversationTemplateModule = void 0;
+const util_1 = require("@proteinjs/util");
+const CreatePackageConversationTemplate_1 = require("./createPackage/CreatePackageConversationTemplate");
+const ConversationTemplateFunctions_1 = require("./ConversationTemplateFunctions");
+const CreateCodeConversationTemplate_1 = require("./createCode/CreateCodeConversationTemplate");
+const CreateAppTemplate_1 = require("./createApp/CreateAppTemplate");
+const conversationTemplates = [
+    CreatePackageConversationTemplate_1.createPackageConversationTemplate,
+    CreateCodeConversationTemplate_1.createCodeConversationTemplate,
+    CreateAppTemplate_1.createAppTemplate,
+];
+class ConversationTemplateModule {
+    constructor(params) {
+        this.logger = new util_1.Logger(this.constructor.name);
+        this.params = params;
+    }
+    getName() {
+        return 'Conversation Template';
+    }
+    searchConversationTemplates(keyword) {
+        this.logger.info(`Searching for conversation template, keyword: ${keyword}`);
+        const conversationNames = this.params.conversationTemplateKeywordIndex[keyword];
+        return conversationNames || [];
+    }
+    getConversationTemplate(conversationTemplateName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const conversationTemplate = this.params.conversationTemplates[conversationTemplateName];
+            if (!conversationTemplate)
+                return {};
+            const instructions = yield conversationTemplate.instructions();
+            return Object.assign(conversationTemplate, { instructions });
+        });
+    }
+    getSystemMessages() {
+        return [
+            `Whenever the user wants to create or talk about something, fisrt use the ${ConversationTemplateFunctions_1.searchConversationTemplatesFunctionName} function to identify if there are relevant conversation templates to use`,
+            `Use the ${ConversationTemplateFunctions_1.getConversationTemplateFunctionName} function to get the conversation template`,
+            `Once you've identified a conversation template that's relevant to the conversation, ask the user if they'd like to use that conversation template`,
+            `If they want to engage in the templated conversation, ask only the conversation template questions (template.questions), then use the user's answers to carry out the conversation template instructions (template.instructions)`,
+        ];
+    }
+    getFunctions() {
+        return [
+            (0, ConversationTemplateFunctions_1.searchConversationTemplatesFunction)(this),
+            (0, ConversationTemplateFunctions_1.getConversationTemplateFunction)(this),
+        ];
+    }
+    getMessageModerators() {
+        return [];
+    }
+}
+exports.ConversationTemplateModule = ConversationTemplateModule;
+class ConversationTemplateModuleFactory {
+    createModule(repoPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = { conversationTemplates: {}, conversationTemplateKeywordIndex: {} };
+            for (let conversationTemplate of conversationTemplates) {
+                params.conversationTemplates[conversationTemplate.name] = conversationTemplate;
+                for (let keyword of conversationTemplate.keywords) {
+                    if (!params.conversationTemplateKeywordIndex[keyword])
+                        params.conversationTemplateKeywordIndex[keyword] = [];
+                    params.conversationTemplateKeywordIndex[keyword].push(conversationTemplate.name);
+                }
+            }
+            return new ConversationTemplateModule(params);
+        });
+    }
+}
+exports.ConversationTemplateModuleFactory = ConversationTemplateModuleFactory;

package/dist/src/template/createApp/CreateAppTemplate.js

@@ -0,0 +1,40 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAppTemplate = void 0;
+const createAppQuestions = [
+    {
+        text: 'What is the name of the app you want to create?',
+    },
+    {
+        text: 'Which directory would you like to create the app in?',
+    },
+];
+const createAppInstructions = () => __awaiter(void 0, void 0, void 0, function* () {
+    // Here we would implement the instructions based on the user's answers to the questions
+    return [
+        'create a directory for the app (if it doesnt already exist), with the same name as the app (replace ` ` with `-`)',
+        'cloneAppTemplatePackages on the app directory',
+        'update the package.json files of the packages you just cloned, set the package names to be app-name-ui and app-name-server',
+        `update the ui/src/Container.tsx and ui/src/SplashPage.tsx files to replace the occurrences of 'appName' with their app name in each file`,
+        'npmInstall each newly cloned package',
+        'runPackageScript(`build`, cwd) each newly cloned package',
+        'describe the packages',
+        'tell the user they can start the server by calling `npm run dev` in the server package',
+    ];
+});
+exports.createAppTemplate = {
+    name: 'Create App',
+    keywords: ['create', 'app', 'create app', 'create new app'],
+    description: 'This template will guide you through the process of creating a new app.',
+    questions: createAppQuestions,
+    instructions: createAppInstructions,
+};

package/dist/src/template/createCode/CreateCodeConversationTemplate.js

@@ -0,0 +1,51 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCodeConversationTemplate = void 0;
+const FsFunctions_1 = require("../../fs/conversation_fs/FsFunctions");
+const PackageFunctions_1 = require("../../fs/package/PackageFunctions");
+exports.createCodeConversationTemplate = {
+    name: 'Create code',
+    keywords: [
+        'create code',
+        'implement',
+        'write code',
+        'generate code',
+        'write software',
+        'build something',
+    ],
+    description: 'User and ai developing together',
+    questions: [],
+    instructions: () => __awaiter(void 0, void 0, void 0, function* () {
+        return [
+            `You are going to generate code for the user, follow these steps:`,
+            `1. Confirm the package they want to work in, if the user didn't already provide one`,
+            `1.a. Use the ${PackageFunctions_1.searchPackagesFunctionName} function to identify the package.json file path`,
+            `1.b. Use the ${FsFunctions_1.readFilesFunctionName} function to read the package.json file, reference this throughout the conversation in the fileSystem`,
+            `1.c. Set the cwd to the directory of the package.json file`,
+            `2. Ask for a file name to work in, if the user didn't alrady provide one`,
+            `2.a. Whenever the user wants to create a new source file, default to creating it in the package src/ folder`,
+            `2.b. Confirm the package-relative file path with the user. Only after the users confirms the path, create the file if it doesn't exist`,
+            `2.b.1. Use the ${FsFunctions_1.fileOrDirectoryExistsFunction.definition.name} function to confirm if a file exists`,
+            `3. Once working in a file, ask the user what they'd like to create`,
+            `3.a. If the user references a library, use the ${PackageFunctions_1.searchLibrariesFunctionName} function to identify local libraries that can be imported`,
+            `3.a.1. Confirm the library file name and package name with the user, if they provide a different library or package name, repeat step 3.a.`,
+            `3.a.2. Call the ${PackageFunctions_1.generateTypescriptDeclarationsFunction.definition.name} function to get the typescript declaration of the library file`,
+            `3.a.3. Use the typescript declaration and the package name to add the import statements to the top of the file`,
+            `3.a.4. Use the ${FsFunctions_1.readFilesFunctionName} function on the package.json if it's not in the fileSystem`,
+            `3.a.5. Check the pacakge.json dependencies, if the imported package is not already a dependency, use the ${PackageFunctions_1.installPackagesFunction.definition.name} function to install it`,
+            `3.a.5.a. Use the ${PackageFunctions_1.searchPackagesFunctionName} on the import package to derermine if it's in the local repo; if it is, calculate the relative path from the cwd package to the package being installed, use that path as the version when installing the package`,
+            `3.b. Generate the code the user asked to create, leveraging the imported library where appropriate`,
+            `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/dist/src/template/createPackage/CreatePackageConversationTemplate.js

@@ -0,0 +1,54 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPackageConversationTemplate = void 0;
+const util_node_1 = require("@proteinjs/util-node");
+const path_1 = __importDefault(require("path"));
+exports.createPackageConversationTemplate = {
+    name: 'Create 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?` },
+        { text: `What should the package name be?` },
+        { text: `What should the package version be?`, optional: true },
+        { text: `Is this a typescript project?` },
+        { text: `Are there any default dependencies you'd like to include?`, optional: true },
+    ],
+    instructions: () => __awaiter(void 0, void 0, void 0, function* () {
+        const jestConfig = yield util_node_1.Fs.readFile(path_1.default.join(__dirname, `./jest.config.js`));
+        const tsConfig = yield util_node_1.Fs.readFile(path_1.default.join(__dirname, `./tsconfig.json`));
+        return [
+            `Create a new package.json with the provided name, version (if one wasn't provided, default to 0.1), and any default dependencies provided`,
+            `Create the package.json in the specified folder, do not create subfolders from the package name`,
+            `If the folder does not exist, create the folder`,
+            `Add these scripts to the package.json: "start": "node ./dist/index.js", "test": "jest"`,
+            `Add these dev dependencies to the package.json: jest`,
+            `If it's a typescript project, add these dev dependencies: @types/jest, ts-jest`,
+            `If it's a typescript project, add these scripts: "watch": "tsc -w -p ."`,
+            `Create an index file in the package root directory (choose extension based on if it's a typescript project or not)`,
+            `Create the following folders in the package directory: src, test`,
+            `Create a jest.config.js file in the test directory with the following content: ${jestConfig}`,
+            `Create a .gitignore file in the package directory that ignores the node_modules and dist directories`,
+            `If it's a typescript project, create a tsconfig.json file in the pakage directory with the following content: ${tsConfig}`,
+        ];
+    }),
+};

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

@@ -0,0 +1,10 @@
+"use strict";
+module.exports = {
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+    transform: {
+        '^.+\\.tsx?$': 'ts-jest',
+    },
+    testMatch: ["**/?(*.)+(spec|test).ts"],
+    setupFiles: ['./test/setup'],
+};

package/dist/src/template/createPackage/tsconfig.json

@@ -0,0 +1,13 @@
+{
+    "compilerOptions": {
+        "target": "es2016",
+        "module": "commonjs",
+        "resolveJsonModule": true,
+        "allowJs": true,
+        "outDir": "./dist",
+        "esModuleInterop": true,
+        "forceConsistentCasingInFileNames": true,
+        "strict": true,
+        "skipLibCheck": true
+    }
+}

package/dist/test/createKeywordFilesIndex.test.js

@@ -0,0 +1,17 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const KeywordToFilesIndexModule_1 = require("../src/fs/keyword_to_files_index/KeywordToFilesIndexModule");
+test('Create keyword-files index', () => __awaiter(void 0, void 0, void 0, function* () {
+    // Example usage
+    const index = new KeywordToFilesIndexModule_1.KeywordToFilesIndexModuleFactory().createKeywordFilesIndex(`${process.cwd()}`);
+    console.log(JSON.stringify(index, null, 2));
+}), 60000);

package/dist/test/openai/openai.generateList.test.js

@@ -0,0 +1,16 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const OpenAi_1 = require("../../src/OpenAi");
+test('generateList should return an array of numbers, counting to 10', () => __awaiter(void 0, void 0, void 0, function* () {
+    const numbers = ['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten'];
+    expect((yield OpenAi_1.OpenAi.generateList([`Create a list of numbers spelled out, from 1 to 10`])).join(' ')).toBe(numbers.join(' '));
+}));

package/dist/test/openai/openai.parseCodeFromMarkdown.test.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const OpenAi_1 = require("../../src/OpenAi");
+const helloWorldCode = "console.log('hello world');";
+const helloWorldWithTicksCode = "console.log('hello ```world');";
+const logXCode = "const x = 'yo';\nconsole.log(x);";
+const testOneBlock = "Sure! I'm a helpful chatbot.\n```typescript\n" + helloWorldCode + "\n```";
+const testOneBlockWithExtraTicks = "Sure! I'm a helpful chatbot.\n```typescript\n" + helloWorldWithTicksCode + "\n```";
+const testTwoBlocks = "Sure! I'm a helpful chatbot.\n```typescript\n" + helloWorldCode + "\n```\n\nI'm still really helpful.\n```typescript\n" + logXCode + "\n```\n\nMore unhelpful chat";
+test('parseCodeFromMarkdown should parse 1 block of code', () => {
+    expect(OpenAi_1.OpenAi.parseCodeFromMarkdown(testOneBlock)).toBe(helloWorldCode);
+});
+test('parseCodeFromMarkdown should parse 1 block of code that contains ticks', () => {
+    expect(OpenAi_1.OpenAi.parseCodeFromMarkdown(testOneBlockWithExtraTicks)).toBe(helloWorldWithTicksCode);
+});
+test('parseCodeFromMarkdown should parse 1 block of code', () => {
+    expect(OpenAi_1.OpenAi.parseCodeFromMarkdown(testTwoBlocks)).toBe(helloWorldCode + '\n\n' + logXCode);
+});

package/dist/test/repo/repo.test.js

@@ -0,0 +1,29 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// test(`Return repo of the source files and the code they depend on`, async () => {
+//   const tableTemplatePath = require.resolve('conversation/src/table.ts');
+//   const repo = await new RepoFactory([tableTemplatePath]).create();
+//   console.log(JSON.stringify(Object.keys(repo.declarations), null, 2));
+// }, 60000);
+// test(`It should be able to reference code`, async () => {
+// }, 60000);
+// test(`Interpret all parameters of a function`, async () => {
+// }, 60000);
+// test(`Gather parameter data from the user`, async () => {
+//   const conversation = new Conversation();
+// }, 60000);
+// test(`Generate code from templates guided by user input`, async () => {
+// }, 60000);
+test(`Create repo`, () => __awaiter(void 0, void 0, void 0, function* () {
+    // console.log(JSON.stringify((await RepoFactory.createRepo(`${process.cwd()}`)).params, null, 4));
+    // console.log(JSON.stringify(await Fs.getFilesInDirectory(`${process.cwd()}`, ['node_modules', 'dist']), null, 4));
+}), 60000);

package/dist/test/setup.js

@@ -0,0 +1 @@
+"use strict";

package/index.ts

@@ -0,0 +1,11 @@
+export * from './src/Sentence';
+export * from './src/Paragraph';
+export * from './src/OpenAi';
+export * from './src/code_template/CodeTemplate';
+export * from './src/Conversation';
+export * from './src/CodegenConversation';
+export * from './src/code_template/Code';
+export * from './src/ConversationModule';
+export * from './src/Function';
+export * from './src/history/MessageModerator';
+export * from './src/history/MessageHistory';

package/jest.config.js

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

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@proteinjs/conversation",
+  "version": "1.0.1",
+  "main": "dist/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "clean": "rm -rf dist/ node_modules/ package-lock.json",
+    "build": "tsc",
+    "watch": "tsc -w -p .",
+    "start": "node ./dist/index.js",
+    "test": "jest"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.6.4",
+    "@types/fs-extra": "11.0.1",
+    "@types/jest": "^29.5.4",
+    "@types/node": "20.5.9",
+    "@types/readline-sync": "1.4.4",
+    "jest": "^29.6.4",
+    "ts-jest": "^29.1.1"
+  },
+  "dependencies": {
+    "@proteinjs/util": "1.0.18",
+    "@proteinjs/util-node": "1.0.21",
+    "fs-extra": "11.1.1",
+    "openai": "4.4.0",
+    "readline-sync": "1.4.10",
+    "tiktoken": "1.0.11",
+    "typescript": "5.2.2"
+  },
+  "gitHead": "20fbdf62cdb42f62ce7972d7f7de91b9bfba3b31"
+}