@proteinjs/conversation 1.0.1

package/dist/src/fs/conversation_fs/FsFunctions.js

@@ -0,0 +1,256 @@
+"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.fsFunctions = exports.moveFunctionName = exports.copyFunctionName = exports.renameFunctionName = exports.getFilePathsMatchingGlobFunctionName = exports.fileOrDirectoryExistsFunction = exports.fileOrDirectoryExistsFunctionName = exports.getRecentlyAccessedFilePathsFunction = exports.getRecentlyAccessedFilePathsFunctionName = exports.writeFilesFunction = exports.writeFilesFunctionName = exports.readFilesFunction = exports.readFilesFunctionName = void 0;
+const util_node_1 = require("@proteinjs/util-node");
+exports.readFilesFunctionName = 'readFiles';
+function readFilesFunction(fsModule) {
+    return {
+        definition: {
+            name: exports.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: (params) => __awaiter(this, void 0, void 0, function* () {
+            fsModule.pushRecentlyAccessedFilePath(params.filePaths);
+            return yield util_node_1.Fs.readFiles(params.filePaths);
+        }),
+        instructions: [
+            `To read files from the local file system, use the ${exports.readFilesFunctionName} function`,
+        ],
+    };
+}
+exports.readFilesFunction = readFilesFunction;
+exports.writeFilesFunctionName = 'writeFiles';
+function writeFilesFunction(fsModule) {
+    return {
+        definition: {
+            name: exports.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: (params) => __awaiter(this, void 0, void 0, function* () {
+            fsModule.pushRecentlyAccessedFilePath(params.files.map(file => file.path));
+            return yield util_node_1.Fs.writeFiles(params.files);
+        }),
+        instructions: [
+            `To write files to the local file system, use the ${exports.writeFilesFunctionName} function`,
+        ],
+    };
+}
+exports.writeFilesFunction = writeFilesFunction;
+exports.getRecentlyAccessedFilePathsFunctionName = 'getRecentlyAccessedFilePaths';
+function getRecentlyAccessedFilePathsFunction(fsModule) {
+    return {
+        definition: {
+            name: exports.getRecentlyAccessedFilePathsFunctionName,
+            description: 'Get paths of files accessed during this conversation, in order from oldest to newest',
+            parameters: {
+                type: 'object',
+                properties: {},
+                required: [],
+            },
+        },
+        call: () => __awaiter(this, void 0, void 0, function* () { return fsModule.getRecentlyAccessedFilePaths(); }),
+    };
+}
+exports.getRecentlyAccessedFilePathsFunction = getRecentlyAccessedFilePathsFunction;
+const createFolderFunctionName = 'createFolder';
+const createFolderFunction = {
+    definition: {
+        name: createFolderFunctionName,
+        description: 'Create a folder/directory',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Path of the new directory',
+                },
+            },
+            required: ['path']
+        },
+    },
+    call: (params) => __awaiter(void 0, void 0, void 0, function* () { return yield util_node_1.Fs.createFolder(params.path); }),
+    instructions: [
+        `To create a folder on the local file system, use the ${createFolderFunctionName} function`,
+    ],
+};
+exports.fileOrDirectoryExistsFunctionName = 'fileOrDirectoryExists';
+exports.fileOrDirectoryExistsFunction = {
+    definition: {
+        name: exports.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: (params) => __awaiter(void 0, void 0, void 0, function* () { return yield util_node_1.Fs.exists(params.path); }),
+    instructions: [
+        `To check if a file or folder exists on the local file system, use the ${exports.fileOrDirectoryExistsFunctionName} function`,
+    ],
+};
+exports.getFilePathsMatchingGlobFunctionName = 'getFilePathsMatchingGlob';
+const getFilePathsMatchingGlobFunction = {
+    definition: {
+        name: exports.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: (params) => __awaiter(void 0, void 0, void 0, function* () { return yield util_node_1.Fs.getFilePathsMatchingGlob(params.dirPrefix, params.glob, params.globIgnorePatterns); }),
+    instructions: [
+        `To get file paths matching a glob, use the ${exports.getFilePathsMatchingGlobFunctionName} function`,
+    ],
+};
+exports.renameFunctionName = 'renameFileOrDirectory';
+const renameFunction = {
+    definition: {
+        name: exports.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: (params) => __awaiter(void 0, void 0, void 0, function* () { return yield util_node_1.Fs.rename(params.oldPath, params.newName); }),
+    instructions: [
+        `To rename a file or directory, use the ${exports.renameFunctionName} function`,
+    ],
+};
+exports.copyFunctionName = 'copyFileOrDirectory';
+const copyFunction = {
+    definition: {
+        name: exports.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: (params) => __awaiter(void 0, void 0, void 0, function* () { return yield util_node_1.Fs.copy(params.sourcePath, params.destinationPath); }),
+    instructions: [
+        `To copy a file or directory, use the ${exports.copyFunctionName} function`,
+    ],
+};
+exports.moveFunctionName = 'moveFileOrDirectory';
+const moveFunction = {
+    definition: {
+        name: exports.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: (params) => __awaiter(void 0, void 0, void 0, function* () { return yield util_node_1.Fs.move(params.sourcePath, params.destinationPath); }),
+    instructions: [
+        `To move a file or directory, use the ${exports.moveFunctionName} function`,
+    ],
+};
+exports.fsFunctions = [
+    createFolderFunction,
+    exports.fileOrDirectoryExistsFunction,
+    getFilePathsMatchingGlobFunction,
+    renameFunction,
+    copyFunction,
+    moveFunction,
+];

package/dist/src/fs/git/GitModule.js

@@ -0,0 +1,45 @@
+"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.GitModuleFactory = exports.GitModule = void 0;
+const util_node_1 = require("@proteinjs/util-node");
+class GitModule {
+    constructor(repoPath) {
+        this.repoPath = repoPath;
+    }
+    getName() {
+        return 'Git';
+    }
+    getSystemMessages() {
+        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() {
+        return [
+            ...util_node_1.gitFunctions,
+        ];
+    }
+    getMessageModerators() {
+        return [];
+    }
+}
+exports.GitModule = GitModule;
+class GitModuleFactory {
+    createModule(repoPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new GitModule(repoPath);
+        });
+    }
+}
+exports.GitModuleFactory = GitModuleFactory;

package/dist/src/fs/keyword_to_files_index/KeywordToFilesIndexFunctions.js

@@ -0,0 +1,65 @@
+"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.searchFilesFunction = exports.searchFilesFunctionName = void 0;
+exports.searchFilesFunctionName = 'searchFiles';
+const searchFilesFunction = (module) => {
+    return {
+        definition: {
+            name: exports.searchFilesFunctionName,
+            description: 'Get file paths to files that contain keyword',
+            parameters: {
+                type: 'object',
+                properties: {
+                    keyword: {
+                        type: 'string',
+                        description: 'Search files for this keyword'
+                    },
+                },
+                required: ['keyword']
+            },
+        },
+        call: (params) => __awaiter(void 0, void 0, void 0, function* () { return module.searchFiles(params); }),
+        instructions: [
+            `If the user is trying to interact with a file, but does not provide a path, you can find file paths that match a keyword using the ${exports.searchFilesFunctionName} function`,
+            `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 ${exports.searchFilesFunctionName} function`,
+            `If the user references a file in a package without providing a path, use the ${exports.searchFilesFunctionName} function on the keyword to find potentially relevant files, and choose the one that references the package name in its path`,
+        ],
+    };
+};
+exports.searchFilesFunction = searchFilesFunction;
+// {
+//   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/dist/src/fs/keyword_to_files_index/KeywordToFilesIndexModule.js

@@ -0,0 +1,89 @@
+"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.KeywordToFilesIndexModuleFactory = exports.KeywordToFilesIndexModule = void 0;
+const util_1 = require("@proteinjs/util");
+const util_node_1 = require("@proteinjs/util-node");
+const path_1 = __importDefault(require("path"));
+const KeywordToFilesIndexFunctions_1 = require("./KeywordToFilesIndexFunctions");
+class KeywordToFilesIndexModule {
+    constructor(params) {
+        this.logger = new util_1.Logger(this.constructor.name);
+        this.params = params;
+    }
+    getName() {
+        return 'Keyword to files index';
+    }
+    searchFiles(params) {
+        this.logger.info(`Searching for file, keyword: ${params.keyword}`);
+        const filePaths = this.params.keywordFilesIndex[params.keyword];
+        return filePaths || [];
+    }
+    getSystemMessages() {
+        return [
+            `If you're searching for something, use the ${KeywordToFilesIndexFunctions_1.searchFilesFunctionName} function to find a file matching the search string`,
+        ];
+    }
+    getFunctions() {
+        return [
+            (0, KeywordToFilesIndexFunctions_1.searchFilesFunction)(this),
+        ];
+    }
+    getMessageModerators() {
+        return [];
+    }
+}
+exports.KeywordToFilesIndexModule = KeywordToFilesIndexModule;
+class KeywordToFilesIndexModuleFactory {
+    constructor() {
+        this.logger = new util_1.Logger(this.constructor.name);
+    }
+    createModule(repoPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.debug(`Creating module for repo: ${repoPath}`);
+            let repoParams = { keywordFilesIndex: {}, dir: repoPath };
+            repoParams.keywordFilesIndex = yield this.createKeywordFilesIndex(repoPath, ['**/node-typescript-parser/**']);
+            this.logger.debug(`Created module for repo: ${repoPath}`);
+            return new KeywordToFilesIndexModule(repoParams);
+        });
+    }
+    /**
+     * 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.
+     */
+    createKeywordFilesIndex(baseDir, globIgnorePatterns = []) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Ensure the base directory has a trailing slash
+            if (!baseDir.endsWith(path_1.default.sep)) {
+                baseDir += path_1.default.sep;
+            }
+            // Get all file paths, recursively, excluding node_modules and dist directories
+            const filePaths = yield util_node_1.Fs.getFilePaths(baseDir, ['**/node_modules/**', '**/dist/**', ...globIgnorePatterns]);
+            const keywordFilesIndex = {};
+            // Process each file path
+            for (const filePath of filePaths) {
+                const fileName = path_1.default.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;
+        });
+    }
+}
+exports.KeywordToFilesIndexModuleFactory = KeywordToFilesIndexModuleFactory;

package/dist/src/fs/package/PackageFunctions.js

@@ -0,0 +1,214 @@
+"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.packageFunctions = exports.uninstallPackagesFunction = exports.uninstallPackagesFunctionName = exports.npmInstallFunction = exports.npmInstallFunctionName = exports.generateTypescriptDeclarationsFunction = exports.generateTypescriptDeclarationsFunctionName = exports.searchLibrariesFunction = exports.searchLibrariesFunctionName = exports.searchPackagesFunction = exports.searchPackagesFunctionName = exports.runPackageScriptFunctionName = exports.installPackagesFunction = exports.installPackagesFunctionName = void 0;
+const util_node_1 = require("@proteinjs/util-node");
+exports.installPackagesFunctionName = 'installPackages';
+exports.installPackagesFunction = {
+    definition: {
+        name: exports.installPackagesFunctionName,
+        description: 'Get the content of files',
+        parameters: {
+            type: 'object',
+            properties: {
+                packages: {
+                    type: 'array',
+                    description: 'Packages to install',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            name: {
+                                type: 'string',
+                                description: 'Name of package',
+                            },
+                            version: {
+                                type: 'string',
+                                description: 'Version of package',
+                            },
+                            exactVersion: {
+                                type: 'boolean',
+                                description: 'If true, freeze the version so subsequent installs do not bump minor versions',
+                            },
+                            development: {
+                                type: 'boolean',
+                                description: 'If true, install as a dev dependency',
+                            },
+                        },
+                        required: ['name'],
+                    },
+                },
+                cwdPath: {
+                    type: 'string',
+                    description: 'The directory to install packages in',
+                }
+            },
+            required: ['packages', 'cwdPath']
+        },
+    },
+    call: (params) => __awaiter(void 0, void 0, void 0, function* () { return yield util_node_1.PackageUtil.installPackages(params.packages, params.cwdPath); }),
+    instructions: [
+        `To install a package, use the ${exports.installPackagesFunctionName} function`,
+    ],
+};
+exports.runPackageScriptFunctionName = 'runPackageScript';
+const runPackageScriptFunction = {
+    definition: {
+        name: exports.runPackageScriptFunctionName,
+        description: 'Run `npm run x`, where `x` is an existing script in a package.json',
+        parameters: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'Name of the script',
+                },
+                cwdPath: {
+                    type: 'string',
+                    description: 'If omitted, defaults to process.cwd',
+                }
+            },
+            required: ['name']
+        },
+    },
+    call: (params) => __awaiter(void 0, void 0, void 0, function* () { return yield util_node_1.PackageUtil.runPackageScript(params.name, params.cwdPath); }),
+    instructions: [
+        `To run a npm script (such as start, test, or watch), use the ${exports.runPackageScriptFunctionName} function`,
+    ],
+};
+exports.searchPackagesFunctionName = 'searchPackages';
+function searchPackagesFunction(packageModule) {
+    return {
+        definition: {
+            name: exports.searchPackagesFunctionName,
+            description: 'Get package.json file paths for package names that include the keyword',
+            parameters: {
+                type: 'object',
+                properties: {
+                    keyword: {
+                        type: 'string',
+                        description: 'Keyword to match package names',
+                    }
+                },
+                required: ['keyword']
+            },
+        },
+        call: (params) => __awaiter(this, void 0, void 0, function* () { return yield packageModule.searchPackages(params.keyword); }),
+        instructions: [
+            `To search for packages in the local repo, use the ${exports.searchPackagesFunctionName} function`,
+        ],
+    };
+}
+exports.searchPackagesFunction = searchPackagesFunction;
+exports.searchLibrariesFunctionName = 'searchLibraries';
+function searchLibrariesFunction(packageModule) {
+    return {
+        definition: {
+            name: exports.searchLibrariesFunctionName,
+            description: 'Return libraries that match the keyword',
+            parameters: {
+                type: 'object',
+                properties: {
+                    keyword: {
+                        type: 'string',
+                        description: 'Keyword to match file names',
+                    }
+                },
+                required: ['keyword']
+            },
+        },
+        call: (params) => __awaiter(this, void 0, void 0, function* () { return yield packageModule.searchLibraries(params.keyword); }),
+        instructions: [
+            `To search for libraries in the local repo, use the ${exports.searchLibrariesFunctionName} function`,
+        ],
+    };
+}
+exports.searchLibrariesFunction = searchLibrariesFunction;
+exports.generateTypescriptDeclarationsFunctionName = 'generateTypescriptDesclarations';
+exports.generateTypescriptDeclarationsFunction = {
+    definition: {
+        name: exports.generateTypescriptDeclarationsFunctionName,
+        description: 'Return the typescript declarations for the files',
+        parameters: {
+            type: 'object',
+            properties: {
+                tsFilePaths: {
+                    type: 'array',
+                    description: 'File paths to generate declarations for',
+                    items: {
+                        type: 'string',
+                    }
+                }
+            },
+            required: ['tsFilePaths']
+        },
+    },
+    call: (params) => __awaiter(void 0, void 0, void 0, function* () { return util_node_1.PackageUtil.generateTypescriptDeclarations(params); }),
+    instructions: [
+        `To generate typescript declarations for a local file, use the ${exports.generateTypescriptDeclarationsFunctionName} function`,
+    ],
+};
+exports.npmInstallFunctionName = 'npmInstall';
+exports.npmInstallFunction = {
+    definition: {
+        name: exports.npmInstallFunctionName,
+        description: 'Run `npm install` in the specified directory',
+        parameters: {
+            type: 'object',
+            properties: {
+                cwdPath: {
+                    type: 'string',
+                    description: 'Directory to execute the command from',
+                }
+            },
+            required: ['cwdPath']
+        },
+    },
+    call: (params) => __awaiter(void 0, void 0, void 0, function* () { return yield util_node_1.PackageUtil.npmInstall(params.cwdPath); }),
+    instructions: [
+        `To run npm install in a specific directory, use the ${exports.npmInstallFunctionName} function`,
+    ],
+};
+exports.uninstallPackagesFunctionName = 'uninstallPackages';
+exports.uninstallPackagesFunction = {
+    definition: {
+        name: exports.uninstallPackagesFunctionName,
+        description: 'Uninstall packages',
+        parameters: {
+            type: 'object',
+            properties: {
+                packageNames: {
+                    type: 'array',
+                    description: 'Packages to uninstall',
+                    items: {
+                        type: 'string',
+                        description: 'Name of package',
+                    },
+                },
+                cwdPath: {
+                    type: 'string',
+                    description: 'The directory to uninstall packages from',
+                }
+            },
+            required: ['packageNames', 'cwdPath']
+        },
+    },
+    call: (params) => __awaiter(void 0, void 0, void 0, function* () { return yield util_node_1.PackageUtil.uninstallPackages(params.packageNames, params.cwdPath); }),
+    instructions: [
+        `To uninstall a package, use the ${exports.uninstallPackagesFunctionName} function`,
+    ],
+};
+exports.packageFunctions = [
+    exports.installPackagesFunction,
+    runPackageScriptFunction,
+    exports.generateTypescriptDeclarationsFunction,
+    exports.npmInstallFunction,
+    exports.uninstallPackagesFunction,
+];