git-coco 0.3.0 → 0.3.2

package/dist/index.js

@@ -1,28 +1,27 @@
 #!/usr/bin/env node
 'use strict';
 
+var yargs = require('yargs');
 var prompts$1 = require('@inquirer/prompts');
+var simpleGit = require('simple-git');
 var fs = require('fs');
 var os = require('os');
 var path = require('path');
 var ini = require('ini');
-var yargs = require('yargs');
-var helpers = require('yargs/helpers');
 var prompts = require('langchain/prompts');
 var pQueue = require('p-queue');
-var chalk = require('chalk');
-var ora = require('ora');
-var now = require('performance-now');
-var prettyMilliseconds = require('pretty-ms');
 var document = require('langchain/document');
 var hf = require('langchain/llms/hf');
 var chains = require('langchain/chains');
 var openai = require('langchain/llms/openai');
 var text_splitter = require('langchain/text_splitter');
 var diff = require('diff');
+var chalk = require('chalk');
 var GPT3NodeTokenizer = require('gpt3-tokenizer');
+var ora = require('ora');
+var now = require('performance-now');
+var prettyMilliseconds = require('pretty-ms');
 var minimatch = require('minimatch');
-var simpleGit = require('simple-git');
 
 function _interopNamespaceDefault(e) {
   var n = Object.create(null);
@@ -175,74 +174,6 @@ function loadXDGConfig(config) {
     return config;
 }
 
-/**
- * Command line options via yargs
- */
-const options = {
-    model: { type: 'string', description: 'LLM/Model-Name' },
-    openAIApiKey: { type: 'string', description: 'OpenAI API Key' },
-    huggingFaceHubApiKey: { type: 'string', description: 'HuggingFace Hub API Key' },
-    tokenLimit: { type: 'number', description: 'Token limit' },
-    prompt: {
-        type: 'string',
-        alias: 'p',
-        description: 'Commit message prompt',
-    },
-    interactive: {
-        type: 'boolean',
-        alias: 'i',
-        description: 'Toggle interactive mode',
-    },
-    commit: {
-        type: 'boolean',
-        alias: 's',
-        description: 'Commit staged changes with generated commit message',
-        default: false,
-    },
-    openInEditor: {
-        type: 'boolean',
-        alias: 'e',
-        description: 'Open commit message in editor before proceeding',
-    },
-    verbose: {
-        type: 'boolean',
-        description: 'Enable verbose logging',
-    },
-    summarizePrompt: {
-        type: 'string',
-        description: 'Large file summary prompt',
-    },
-    ignoredFiles: {
-        type: 'array',
-        description: 'Ignored files',
-    },
-    ignoredExtensions: {
-        type: 'array',
-        description: 'Ignored extensions',
-    },
-};
-/**
- * Load command line flags via yargs
- *
- * @returns {Partial<Config>} Updated config
- */
-const loadArgv = () => {
-    return yargs(helpers.hideBin(process.argv)).options(options).parseSync();
-};
-/**
- * Load command line flags
- *
- * Note: Arugments are parsed using yargs.
- *
- * @param {Config} config
- * @returns {Config} Updated config
- **/
-function loadCmdLineFlags(config) {
-    const argv = loadArgv();
-    config = { ...config, ...argv };
-    return config;
-}
-
 const template$1 = `Write informative git commit message based on the diffs & file changes provided in the "Diff Summary" section.  
 Commit Messages must have a short description that is less than 50 characters followed by a newline character and then a more verbose detailed description.
 - Write concisely using an informal tone
@@ -305,7 +236,7 @@ const DEFAULT_CONFIG = {
  *
  * @returns {Config} application config
  **/
-function loadConfig() {
+function loadConfig(argv = {}) {
     // Default config
     let config = DEFAULT_CONFIG;
     config = loadGitignore(config);
@@ -314,60 +245,7 @@ function loadConfig() {
     config = loadGitConfig(config);
     config = loadProjectConfig(config);
     config = loadEnvConfig(config);
-    config = loadCmdLineFlags(config);
-    return config;
-}
-const config = loadConfig();
-
-class Logger {
-    constructor(config) {
-        this.config = config;
-        this.spinner = null;
-    }
-    log(message, options = { color: 'blue' }) {
-        let outputMessage = message;
-        if (options.color) {
-            outputMessage = chalk[options.color](outputMessage);
-        }
-        console.log(outputMessage);
-        return this;
-    }
-    verbose(message, options = {}) {
-        if (!this.config?.verbose) {
-            return this;
-        }
-        this.log(message, options);
-        return this;
-    }
-    startTimer() {
-        this.timerStart = now();
-        return this;
-    }
-    stopTimer(message, options = { color: 'yellow' }) {
-        if (!this.config?.verbose || !this.timerStart) {
-            return this;
-        }
-        const elapsedTime = prettyMilliseconds(now() - this.timerStart);
-        let outputMessage = message
-            ? `${message} (⏲ ${elapsedTime})`
-            : `⏲ ${elapsedTime}`;
-        if (options.color) {
-            outputMessage = chalk[options.color](outputMessage);
-        }
-        console.log(outputMessage);
-        return this;
-    }
-    startSpinner(message, options = { color: 'green' }) {
-        const spinnerMessage = options.color ? chalk[options.color](message) : message;
-        this.spinner = ora(spinnerMessage).start();
-        return this;
-    }
-    stopSpinner(message = '', options = { mode: 'succeed', color: 'green' }) {
-        const spinnerMessage = options?.color ? chalk[options.color](message) : message;
-        this.spinner?.[options.mode || 'succeed'](spinnerMessage);
-        this.spinner = null;
-        return this;
-    }
+    return { ...config, ...argv };
 }
 
 /**
@@ -454,8 +332,7 @@ const defaultOutputCallback = (group) => {
     }
     return output;
 };
-async function summarizeDiffs(rootDiffNode, { tokenizer, maxTokens = 2048, textSplitter, chain, handleOutput = defaultOutputCallback, }) {
-    const logger = new Logger(config);
+async function summarizeDiffs(rootDiffNode, { tokenizer, logger, maxTokens = 2048, textSplitter, chain, handleOutput = defaultOutputCallback, }) {
     const queue = new pQueue({ concurrency: 8 });
     logger.startTimer().startSpinner(`Organizing Diffs...`, { color: 'blue' });
     const directoryDiffs = createDirectoryDiffs(rootDiffNode);
@@ -541,7 +418,7 @@ const createDiffTree = (changes) => {
 /**
  * Asynchronously collect diffs for a given node and its children.
  */
-async function collectDiffs(node, getFileDiff, tokenizer, logger = new Logger(config)) {
+async function collectDiffs(node, getFileDiff, tokenizer, logger) {
     // Collect diffs for the files of the current node
     const diffPromises = node.files.map(async (nodeFile) => {
         const diff = await getFileDiff(nodeFile);
@@ -559,7 +436,7 @@ async function collectDiffs(node, getFileDiff, tokenizer, logger = new Logger(co
         };
     });
     // Collect diffs for the children of the current node
-    const childrenPromises = Array.from(node.children.values()).map(async (child) => collectDiffs(child, getFileDiff, tokenizer));
+    const childrenPromises = Array.from(node.children.values()).map(async (child) => collectDiffs(child, getFileDiff, tokenizer, logger));
     const [diffs, children] = await Promise.all([
         Promise.all(diffPromises),
         Promise.all(childrenPromises),
@@ -573,36 +450,65 @@ async function collectDiffs(node, getFileDiff, tokenizer, logger = new Logger(co
 
 /**
  * Get LLM Model Based on Configuration
- *
  * @param fields
  * @param configuration
  * @returns LLM Model
  */
-function getModel(fields, configuration) {
-    const [llm, model] = config.model.split(/\/(.*)/s);
+function getModel(name, key, fields, configuration) {
+    const [llm, model] = name.split(/\/(.*)/s);
     if (!model) {
-        throw new Error(`Invalid model: ${config.model}`);
+        throw new Error(`Invalid model: ${name}`);
     }
     switch (llm) {
         case 'huggingface':
             return new hf.HuggingFaceInference({
                 model: model,
-                apiKey: config.huggingFaceHubApiKey,
+                apiKey: key,
                 maxConcurrency: 4,
                 ...fields,
             });
         case 'openai':
         default:
             return new openai.OpenAI({
-                openAIApiKey: config.openAIApiKey,
+                openAIApiKey: key,
                 modelName: model,
                 ...fields,
             }, configuration);
     }
 }
+/**
+ * Retrieve appropriate API key based on selected model
+ * @param name
+ * @param options
+ * @returns
+ */
+function getModelAPIKey(name, options) {
+    const [llm, model] = name.split(/\/(.*)/s);
+    if (!model) {
+        throw new Error(`Invalid model: ${name}`);
+    }
+    switch (llm) {
+        case 'huggingface':
+            return options.huggingFaceHubApiKey;
+        case 'openai':
+        default:
+            return options.openAIApiKey;
+    }
+}
+/**
+ * Get Recursive Character Text Splitter
+ * @param options
+ * @returns
+ */
 function getTextSplitter(options = {}) {
     return new text_splitter.RecursiveCharacterTextSplitter(options);
 }
+/**
+ * Get Summarization Chain
+ * @param model
+ * @param options
+ * @returns
+ */
 function getChain(model, options = { type: 'map_reduce' }) {
     return chains.loadSummarizationChain(model, options);
 }
@@ -616,6 +522,12 @@ function getPrompt({ template, variables, fallback }) {
         })
         : fallback);
 }
+/**
+ * Verify  template string contains all required input variables
+ * @param text template string
+ * @param inputVariables template variables
+ * @returns boolean or error message
+ */
 function validatePromptTemplate(text, inputVariables) {
     if (!text) {
         return 'Prompt template cannot be empty';
@@ -669,8 +581,7 @@ const getDiff = async (nodeFile, { git, logger, }) => {
 };
 
 const MAX_TOKENS_PER_SUMMARY = 2048;
-const fileChangeParser = async (changes, { tokenizer, git, model }) => {
-    const logger = new Logger(config);
+const fileChangeParser = async (changes, { tokenizer, git, model, logger }) => {
     const textSplitter = getTextSplitter({ chunkSize: 2000, chunkOverlap: 125, });
     const summarizationChain = getChain(model, {
         type: 'map_reduce',
@@ -691,6 +602,7 @@ const fileChangeParser = async (changes, { tokenizer, git, model }) => {
         maxTokens: MAX_TOKENS_PER_SUMMARY,
         textSplitter,
         chain: summarizationChain,
+        logger
     });
     logger.stopTimer(`\nSummary generated for ${changes.length} staged files`, { color: 'green' });
     return summary;
@@ -726,6 +638,57 @@ const getTokenizer = () => {
     return tokenizer;
 };
 
+class Logger {
+    constructor(config) {
+        this.config = config;
+        this.spinner = null;
+    }
+    log(message, options = { color: 'blue' }) {
+        let outputMessage = message;
+        if (options.color) {
+            outputMessage = chalk[options.color](outputMessage);
+        }
+        console.log(outputMessage);
+        return this;
+    }
+    verbose(message, options = {}) {
+        if (!this.config?.verbose) {
+            return this;
+        }
+        this.log(message, options);
+        return this;
+    }
+    startTimer() {
+        this.timerStart = now();
+        return this;
+    }
+    stopTimer(message, options = { color: 'yellow' }) {
+        if (!this.config?.verbose || !this.timerStart) {
+            return this;
+        }
+        const elapsedTime = prettyMilliseconds(now() - this.timerStart);
+        let outputMessage = message
+            ? `${message} (⏲ ${elapsedTime})`
+            : `⏲ ${elapsedTime}`;
+        if (options.color) {
+            outputMessage = chalk[options.color](outputMessage);
+        }
+        console.log(outputMessage);
+        return this;
+    }
+    startSpinner(message, options = { color: 'green' }) {
+        const spinnerMessage = options.color ? chalk[options.color](message) : message;
+        this.spinner = ora(spinnerMessage).start();
+        return this;
+    }
+    stopSpinner(message = '', options = { mode: 'succeed', color: 'green' }) {
+        const spinnerMessage = options?.color ? chalk[options.color](message) : message;
+        this.spinner?.[options.mode || 'succeed'](spinnerMessage);
+        this.spinner = null;
+        return this;
+    }
+}
+
 const llm = async ({ llm, prompt, variables }) => {
     if (!llm || !prompt || !variables) {
         throw new Error('The input parameters "llm", "prompt", and "variables" are all required.');
@@ -783,6 +746,7 @@ const getSummaryText = (file, change) => {
     return `${status}: ${file.path}`;
 };
 
+const config = loadConfig();
 const DEFAULT_IGNORED_FILES = config?.ignoredFiles?.length ? config.ignoredFiles : [];
 const DEFAULT_IGNORED_EXTENSIONS = config?.ignoredExtensions?.length ? config.ignoredExtensions : [];
 async function getChanges(git, options = {}) {
@@ -837,62 +801,117 @@ async function getChanges(git, options = {}) {
 
 const noResult = async ({ git, logger }) => {
     const { staged, unstaged, untracked } = await getChanges(git);
-    if (staged.length > 0) {
+    const hasStaged = staged && staged.length > 0;
+    const hasUnstaged = unstaged && unstaged.length > 0;
+    const hasUntracked = untracked && untracked.length > 0;
+    if (hasStaged) {
         logger.log(`Staged files detected, but no summary generated...`, { color: 'red' });
         logger.log(`Files are likely either:\n  • changed files are ignored\n  • file diff is too large.`, { color: 'yellow' });
     }
-    else if (unstaged && unstaged.length > 0) {
-        logger.log('No staged files detected, but unstaged files detected.', { color: 'yellow' });
-        logger.verbose(`\n Unstaged Changes: \n ${unstaged.map(({ summary }) => summary).join('\n ')}`, {
-            color: 'yellow',
-        });
-    }
-    else if (untracked && untracked.length > 0) {
-        logger.log('No staged files detected, but untracked files detected.', { color: 'yellow' });
-        logger.verbose(`\n Untracked Changes: \n ${untracked.map(({ summary }) => summary).join('\n ')}`, {
-            color: 'yellow',
-        });
+    else if (hasUnstaged || hasUntracked) {
+        logger.log('Forget something? No staged changes found... 👻', { color: 'red' });
+        if (hasUnstaged) {
+            logger.log('\nDetected unstaged changes', { color: 'yellow' });
+            logger.verbose(`\t${unstaged.map(({ summary }) => summary).join('\n\t')}`, {
+                color: 'red',
+            });
+        }
+        if (hasUntracked) {
+            logger.log('\nDetected untracked changes', { color: 'yellow' });
+            logger.verbose(`\t${untracked.map(({ summary }) => summary).join('\n\t')}`, {
+                color: 'red',
+            });
+        }
     }
     else {
-        logger.log('No repo changes detected.', { color: 'yellow' });
+        logger.log('No repo changes detected. 👀', { color: 'blue' });
     }
-    process.exit(0);
 };
 
 async function createCommit(commitMsg, git) {
     return await git.commit(commitMsg);
 }
 
-const argv = loadArgv();
+// const argv = loadArgv()
 const tokenizer = getTokenizer();
 const git = simpleGit.simpleGit();
-async function main(options) {
-    const logger = new Logger(config);
-    if (!config.openAIApiKey) {
+const command = ['commit', '$0'];
+const description = 'Generate a commit message based on the diff summary';
+const builder = {
+    model: { type: 'string', description: 'LLM/Model-Name' },
+    openAIApiKey: {
+        type: 'string',
+        description: 'OpenAI API Key',
+        conflicts: 'huggingFaceHubApiKey',
+    },
+    huggingFaceHubApiKey: {
+        type: 'string',
+        description: 'HuggingFace Hub API Key',
+        conflicts: 'openAIApiKey',
+    },
+    tokenLimit: { type: 'number', description: 'Token limit' },
+    prompt: {
+        type: 'string',
+        alias: 'p',
+        description: 'Commit message prompt',
+    },
+    i: {
+        type: 'boolean',
+        alias: 'interactive',
+        description: 'Toggle interactive mode',
+    },
+    s: {
+        type: 'boolean',
+        description: 'Automatically commit staged changes with generated commit message',
+        default: false,
+    },
+    e: {
+        type: 'boolean',
+        alias: 'edit',
+        description: 'Open commit message in editor before proceeding',
+    },
+    summarizePrompt: {
+        type: 'string',
+        description: 'Large file summary prompt',
+    },
+    ignoredFiles: {
+        type: 'array',
+        description: 'Ignored files',
+    },
+    ignoredExtensions: {
+        type: 'array',
+        description: 'Ignored extensions',
+    },
+};
+async function handler(argv) {
+    const options = loadConfig(argv);
+    const logger = new Logger(options);
+    const key = getModelAPIKey(options.model, options);
+    if (!key) {
         logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
         process.exit(1);
     }
-    const model = getModel({
+    const model = getModel(options.model, key, {
         temperature: 0.4,
         maxConcurrency: 10,
-        openAIApiKey: config.openAIApiKey,
     });
-    const INTERACTIVE = config?.mode === 'interactive' || options.interactive;
+    const INTERACTIVE = options?.mode === 'interactive' || options.interactive;
     const { staged: changes } = await getChanges(git);
     let summary = '';
     let commitMsg = '';
-    let promptTemplate = config?.prompt || '';
+    let promptTemplate = options?.prompt || '';
     let modifyPrompt = false;
     while (true) {
         if (changes.length !== 0 && !summary.length) {
             logger.verbose(`\nChanged Files: \n ${changes.map(({ summary }) => summary).join('\n ')}`, {
                 color: 'blue',
             });
-            summary = await fileChangeParser(changes, { tokenizer, git, model });
+            summary = await fileChangeParser(changes, { tokenizer, git, model, logger });
         }
         // Handle empty summary
         if (!summary.length) {
-            noResult({ git, logger });
+            await noResult({ git, logger });
+            process.exit(0);
         }
         // Prompt user for commit template prompt, if necessary
         if (modifyPrompt) {
@@ -968,7 +987,7 @@ async function main(options) {
                 process.exit(0);
             }
             if (reviewAnswer === 'edit') {
-                config.openInEditor = true;
+                options.openInEditor = true;
             }
             if (reviewAnswer === 'retryFull') {
                 summary = '';
@@ -987,7 +1006,7 @@ async function main(options) {
                 continue;
             }
         }
-        if (config.openInEditor) {
+        if (options.openInEditor) {
             commitMsg = await prompts$1.editor({
                 message: 'Edit the commit message',
                 default: commitMsg,
@@ -1002,7 +1021,7 @@ async function main(options) {
         }
         const MODE = (options.interactive && 'interactive') ||
             (options.commit && 'interactive') ||
-            config?.mode ||
+            options?.mode ||
             'stdout';
         // Handle resulting commit message
         switch (MODE) {
@@ -1018,4 +1037,28 @@ async function main(options) {
         process.exit(0);
     }
 }
-main(argv).catch(console.error);
+
+var commit = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  builder: builder,
+  command: command,
+  description: description,
+  handler: handler
+});
+
+yargs
+    .scriptName('coco')
+    .commandDir('./commands', {
+    extensions: ['ts'],
+})
+    .demandCommand()
+    .strict()
+    .option('h', { alias: 'help' })
+    .option('v', {
+    alias: 'verbose',
+    type: 'boolean',
+    description: 'Run with verbose logging',
+}).argv;
+
+exports.commit = commit;
+exports.loadConfig = loadConfig;

package/dist/lib/config/{index.d.ts → loadConfig.d.ts}

@@ -22,6 +22,4 @@ export declare const DEFAULT_CONFIG: Config;
  *
  * @returns {Config} application config
  **/
-export declare function loadConfig(): Config;
-declare const config: Config;
-export default config;
+export declare function loadConfig(argv?: {}): Config;

package/dist/lib/langchain/utils.d.ts

@@ -5,17 +5,35 @@ import { BaseLLMParams } from 'langchain/llms/base';
 import { AzureOpenAIInput, OpenAIInput, OpenAI } from 'langchain/llms/openai';
 import { RecursiveCharacterTextSplitter, RecursiveCharacterTextSplitterParams } from 'langchain/text_splitter';
 import { ConfigurationParameters } from 'openai';
+import { BaseCommandOptions } from '../../types';
 /**
  * Get LLM Model Based on Configuration
- *
  * @param fields
  * @param configuration
  * @returns LLM Model
  */
-export declare function getModel(fields?: (Partial<OpenAIInput> & Partial<AzureOpenAIInput> & BaseLLMParams & {
+export declare function getModel(name: string, key: string, fields?: (Partial<OpenAIInput> & Partial<AzureOpenAIInput> & BaseLLMParams & {
     configuration?: ConfigurationParameters | undefined;
 }) | undefined, configuration?: ConfigurationParameters | undefined): OpenAI | HuggingFaceInference;
+/**
+ * Retrieve appropriate API key based on selected model
+ * @param name
+ * @param options
+ * @returns
+ */
+export declare function getModelAPIKey(name: string, options: BaseCommandOptions): string;
+/**
+ * Get Recursive Character Text Splitter
+ * @param options
+ * @returns
+ */
 export declare function getTextSplitter(options?: Partial<RecursiveCharacterTextSplitterParams>): RecursiveCharacterTextSplitter;
+/**
+ * Get Summarization Chain
+ * @param model
+ * @param options
+ * @returns
+ */
 export declare function getChain(model: ReturnType<typeof getModel>, options?: SummarizationChainParams): import("langchain/chains").StuffDocumentsChain | import("langchain/chains").MapReduceDocumentsChain | import("langchain/chains").RefineDocumentsChain;
 type CreatePromptInput = {
     template?: string;
@@ -23,5 +41,11 @@ type CreatePromptInput = {
     fallback?: PromptTemplate;
 };
 export declare function getPrompt({ template, variables, fallback }: CreatePromptInput): PromptTemplate;
+/**
+ * Verify  template string contains all required input variables
+ * @param text template string
+ * @param inputVariables template variables
+ * @returns boolean or error message
+ */
 export declare function validatePromptTemplate(text: string, inputVariables: string[]): string | true;
 export {};

package/dist/lib/parsers/default/utils/collectDiffs.d.ts

@@ -5,4 +5,4 @@ import { DiffTreeNode } from './createDiffTree';
 /**
  * Asynchronously collect diffs for a given node and its children.
  */
-export declare function collectDiffs(node: DiffTreeNode, getFileDiff: (change: FileChange) => Promise<string>, tokenizer: GPT3Tokenizer, logger?: Logger): Promise<DiffNode>;
+export declare function collectDiffs(node: DiffTreeNode, getFileDiff: (change: FileChange) => Promise<string>, tokenizer: GPT3Tokenizer, logger: Logger): Promise<DiffNode>;

package/dist/lib/parsers/default/utils/summarizeDiffs.d.ts

@@ -1,5 +1,6 @@
 import GPT3Tokenizer from 'gpt3-tokenizer';
 import { DirectoryDiff, DiffNode } from '../../../types';
+import { Logger } from '../../../utils/logger';
 import { SummarizeContext } from '../../../langchain/chains/summarize';
 /**
  * Create groups from a given node info.
@@ -17,8 +18,9 @@ export declare function summarizeDirectoryDiff(directory: DirectoryDiff, { chain
 declare const defaultOutputCallback: (group: DirectoryDiff) => string;
 type SummarizeDiffsOptions = {
     tokenizer: GPT3Tokenizer;
+    logger: Logger;
     maxTokens: number;
     handleOutput?: typeof defaultOutputCallback;
 } & SummarizeContext;
-export declare function summarizeDiffs(rootDiffNode: DiffNode, { tokenizer, maxTokens, textSplitter, chain, handleOutput, }: SummarizeDiffsOptions): Promise<string>;
+export declare function summarizeDiffs(rootDiffNode: DiffNode, { tokenizer, logger, maxTokens, textSplitter, chain, handleOutput, }: SummarizeDiffsOptions): Promise<string>;
 export {};

package/dist/lib/parsers/noResult.d.ts

@@ -3,4 +3,4 @@ import { SimpleGit } from 'simple-git';
 export declare const noResult: ({ git, logger }: {
     git: SimpleGit;
     logger: Logger;
-}) => Promise<never>;
+}) => Promise<void>;

package/dist/lib/types.d.ts

@@ -1,6 +1,7 @@
 import GPT3Tokenizer from 'gpt3-tokenizer';
 import { getModel } from './langchain/utils';
 import { SimpleGit } from 'simple-git';
+import { Logger } from './utils/logger';
 export type FileChangeStatus = 'modified' | 'renamed' | 'added' | 'deleted' | 'untracked' | 'unknown';
 export interface FileChange {
     summary: string;
@@ -30,5 +31,6 @@ export interface BaseParser {
         tokenizer: GPT3Tokenizer;
         model: ReturnType<typeof getModel>;
         git: SimpleGit;
+        logger: Logger;
     }): Promise<string>;
 }