autoforce 0.1.1

package/lib/helpers/taskFunctions.js

@@ -0,0 +1,479 @@
+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());
+    });
+};
+import { execSync } from "child_process";
+import context from "./context.js";
+import { logError } from "./color.js";
+import metadata from './metadata.js';
+import prompts from "prompts";
+import templateGenerator from "./template.js";
+import { getColored } from "./color.js";
+function createTemplate(templateFolder, templateExtension, template, filename, folder, context) {
+    if (!template || !filename || !templateFolder || !templateExtension) {
+        return;
+    }
+    const templateEngine = templateGenerator(templateFolder, templateExtension);
+    const formulas = {
+        today: Date.now(),
+        filename
+    };
+    const view = Object.assign(Object.assign({}, formulas), context);
+    templateEngine.read(template);
+    templateEngine.render(view);
+    templateEngine.save(filename, folder);
+}
+function convertArgsToString(args) {
+    let argsString = '';
+    if (Array.isArray(args)) {
+        for (const argName of args) {
+            argsString += context.merge(argName) + ' ';
+        }
+    }
+    else if (typeof args === 'object') {
+        for (const argName in args) {
+            if (!args[argName]) {
+                argsString += argName + ' ';
+            }
+            else {
+                argsString += argName + '=' + context.merge(args[argName]) + ' ';
+            }
+        }
+    }
+    return argsString;
+}
+export function executeCommand(step) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            context.set('command', step.command + ' ' + convertArgsToString(step.arguments));
+            execSync(step.command + ' ' + convertArgsToString(step.arguments), { stdio: 'inherit' });
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    });
+}
+export function validateCommand(step) {
+    if (step.command && typeof step.command == 'string') {
+        return true;
+    }
+    return false;
+}
+export function validateFunction(step) {
+    if (typeof taskFunctions[step.function] !== 'function') {
+        logError(`No se encontro la funcion ${step.function}`);
+        return false;
+    }
+    if (typeof step.arguments !== 'undefined') {
+        if (typeof step.arguments !== 'object') {
+            logError(`La funcion ${step.function} recibio un argumento de tipo ${typeof step.arguments} y solo soporta object`);
+            return false;
+        }
+    }
+    return true;
+}
+function getParams(func) {
+    // String representation of the function code
+    let str = func.toString();
+    str = str.replace(/\/\*[\s\S]*?\*\//g, '')
+        .replace(/\/\/(.)*/g, '')
+        .replace(/{[\s\S]*}/, '')
+        .replace(/=>/g, '')
+        .trim();
+    // Start parameter names after first '('
+    const start = str.indexOf("(") + 1;
+    // End parameter names is just before last ')'
+    const end = str.length - 1;
+    const result = str.substring(start, end).split(", ");
+    const params = [];
+    result.forEach(element => {
+        element = element.replace(/=[\s\S]*/g, '').trim();
+        if (element.length > 0) {
+            params.push(element);
+        }
+    });
+    return params;
+}
+function createArray(fields, record) {
+    const fieldArray = [];
+    for (const field of fields) {
+        const value = record[field];
+        fieldArray.push(value);
+    }
+    return fieldArray;
+}
+function askForContinue(message) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const answer = yield prompts([
+            {
+                type: "confirm",
+                name: "continue",
+                initial: true,
+                message
+            }
+        ]);
+        return answer.continue;
+    });
+}
+function askForCommitMessage() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const answer = yield prompts([
+            {
+                type: "text",
+                name: "message",
+                initial: "fix",
+                validate: value => value.length > 0 ? true : "El mensaje es requerido",
+                message: "Mensaje del commit"
+            }
+        ]);
+        return answer.message;
+    });
+}
+export function getCurrentOrganization() {
+    const salidaConfig = executeShell('sf config get target-org --json');
+    const salidaConfigJson = JSON.parse(salidaConfig);
+    const targetOrg = salidaConfigJson.result[0];
+    const salidaOrgList = executeShell('sf org list --json');
+    const salidaOrgListJson = JSON.parse(salidaOrgList);
+    for (const orgType in salidaOrgListJson.result) {
+        for (const orgObject of salidaOrgListJson.result[orgType]) {
+            if (orgObject.alias === targetOrg.value) {
+                if ((orgObject === null || orgObject === void 0 ? void 0 : orgObject.isExpired) === true) {
+                    throw new Error(`La scratch ${orgObject.alias} ha expirado!`);
+                }
+                return orgObject;
+            }
+        }
+    }
+    throw new Error(`No se encontro la organizacion ${targetOrg.value} verifique que este activa con: sf org list. `);
+}
+// type: 'scratchOrgs', 'sandboxes', others
+export function getOrganizationObject(alias, type = 'scratchOrgs') {
+    const salida = executeShell('sf org list --json');
+    const salidaJson = JSON.parse(salida);
+    const orgObject = salidaJson.result[type].filter(scratch => scratch.alias === alias)[0];
+    if ((orgObject === null || orgObject === void 0 ? void 0 : orgObject.isExpired) === true) {
+        throw new Error(`La scratch ${orgObject.alias} ha expirado!`);
+    }
+    return orgObject;
+}
+export function getTargetOrg() {
+    const salida = executeShell('sf force config get target-org --json');
+    const salidaJson = JSON.parse(salida);
+    return salidaJson.result[0].value;
+}
+export function getBranchName() {
+    try {
+        return executeShell("git branch --show-current");
+    }
+    catch (error) {
+        console.log(error);
+    }
+    return '';
+}
+export function executeFunction(step) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let returnValue = false;
+        const functionName = step.function;
+        if (typeof taskFunctions[functionName] === 'function') {
+            if (step.arguments && typeof step.arguments === 'object') {
+                let mergedArgs = context.mergeArgs(step.arguments);
+                if (!Array.isArray(mergedArgs)) {
+                    const paramNames = getParams(taskFunctions[functionName]);
+                    mergedArgs = createArray(paramNames, mergedArgs);
+                }
+                returnValue = yield taskFunctions[functionName](...mergedArgs);
+            }
+            else {
+                returnValue = yield taskFunctions[functionName]();
+            }
+        }
+        else {
+            throw new Error(`No se encontro la funcion ${functionName}`);
+        }
+        return returnValue;
+    });
+}
+export function executeShell(command) {
+    try {
+        const buffer = execSync(command);
+        const salida = buffer.toString().trim();
+        return (salida.endsWith("\n") ? salida.slice(0, -1) : salida);
+    }
+    catch (_a) {
+        return '';
+    }
+}
+function getFilesChanged() {
+    const files = [];
+    const salida = executeShell('git diff origin/main --raw');
+    for (const line of salida.split('\n')) {
+        files.push(line.split(/[ |\t]/)[5]);
+    }
+    return files;
+}
+export const taskFunctions = {
+    docProcess() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!context.process) {
+                return false;
+            }
+            const files = getFilesChanged();
+            if (files.length > 0) {
+                for (const component in metadata) {
+                    const helper = metadata[component];
+                    const items = helper.getItems(files);
+                    if (items.length > 0) {
+                        context.addProcessMetadata(component, items);
+                        helper.execute(items, context.process, context.module);
+                    }
+                }
+            }
+            return true;
+        });
+    },
+    retrieveCode() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tryToRetrieve = yield askForContinue("Desea bajar los cambios?");
+            if (!tryToRetrieve) {
+                return false;
+            }
+            executeShell(`sf project retrieve start`);
+            return yield this.validateScratch();
+        });
+    },
+    validateScratch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const salida = executeShell("sf project retrieve preview");
+            context.salida = salida;
+            const noHayCambios = salida.indexOf('No files will be deleted') !== -1 && salida.indexOf('No files will be retrieved') !== -1 && salida.indexOf('No conflicts found') !== -1;
+            // Probar de bajarlos // sf project retrieve start
+            return noHayCambios;
+        });
+    },
+    commitChanges() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tryToCommit = yield askForContinue("Desea commitear los cambios?");
+            if (!tryToCommit) {
+                return false;
+            }
+            const message = yield askForCommitMessage();
+            executeShell(`git add --all`);
+            executeShell(`git commit -m ${message}`);
+            return yield this.checkCommitPending();
+        });
+    },
+    publishBranch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const branchName = context.branchName;
+                const salida = executeShell(`git push origin ${branchName}`);
+                return salida ? false : true;
+            }
+            catch (error) {
+                console.log(error);
+            }
+            // mergeBranch
+            return false;
+        });
+    },
+    createPullRequest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (context.gitApi === undefined || context.branchName === undefined || context.issueNumber === undefined) {
+                return false;
+            }
+            try {
+                context.issueFromBranch(context.branchName);
+                const result = yield context.gitApi.createPullRequest(context.branchName, `resolves #${context.issueNumber} `, 'AI not implemented yet');
+                return result;
+            }
+            catch (error) {
+                console.log(error);
+            }
+            // mergeBranch
+            return false;
+        });
+    },
+    cancelIssue() {
+        console.log('Not implemented');
+        return false;
+    },
+    deployIssue() {
+        console.log('Not implemented');
+        return false;
+    },
+    rollbackIssue() {
+        console.log('Not implemented');
+        return false;
+    },
+    createIssue(title, label) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (context.projectApi === undefined) {
+                return false;
+            }
+            const issueNumber = yield context.projectApi.createIssue(title, 'Backlog', label);
+            if (issueNumber) {
+                console.log(`Se creao el issue ${issueNumber}`);
+                return true;
+            }
+            return false;
+        });
+    },
+    createTemplate(template, folder, name, identifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const filename = name.toLocaleLowerCase().replaceAll(' ', '-') + '.md';
+            createTemplate('.', 'md', template, filename, folder, { name, identifier });
+            return true;
+        });
+    },
+    validateIssue(issueNumber, states) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (context.projectApi === undefined) {
+                return false;
+            }
+            const issue = yield context.projectApi.getIssueObject(issueNumber);
+            if (!issue.state) {
+                return false;
+            }
+            const arrayStates = states.toLocaleLowerCase().replace(' ', '').split(',');
+            return arrayStates.includes(issue.state.toLocaleLowerCase().replace(' ', ''));
+        });
+    },
+    validaNoseaBranchActual(newBranchName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getBranchName() !== newBranchName;
+        });
+    },
+    checkCommitPending() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const cambios = executeShell("git status --porcelain=v1");
+                context.salida = cambios;
+                return cambios == '';
+            }
+            catch (error) {
+                console.log(error);
+            }
+            return false;
+        });
+    },
+    createBranch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const newBranchName = context.newBranchName;
+                executeShell(`git checkout -b ${newBranchName} origin/main`);
+                context.set('branchName', this.getBranchName());
+                return true;
+            }
+            catch (error) {
+                console.log(error);
+            }
+            // mergeBranch
+            return false;
+        });
+    },
+    mergeBranch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                executeShell(`git fetch`);
+                executeShell(`git merge origin/main`);
+                return true;
+            }
+            catch (error) {
+                console.log(error);
+            }
+            return false;
+        });
+    },
+    moveIssue(issueNumber, state) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (context.projectApi === undefined) {
+                return false;
+            }
+            const result = yield context.projectApi.moveIssue(issueNumber, state);
+            return result;
+        });
+    },
+    assignBranchToIssue(issueNumber, newBranchName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (context.gitApi === undefined) {
+                return false;
+            }
+            const commitSha = executeShell(`git rev-parse --verify main`);
+            const result = yield context.gitApi.assignBranchToIssue(issueNumber, newBranchName, commitSha);
+            return result;
+        });
+    },
+    assignIssueToMe(issueNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!context.projectApi) {
+                return false;
+            }
+            const result = yield context.projectApi.assignIssueToMe(issueNumber);
+            return result;
+        });
+    },
+    viewIssue(issueNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!context.projectApi) {
+                return false;
+            }
+            const result = yield context.projectApi.getIssueObject(issueNumber);
+            // Branch    
+            if (result.branch) {
+                console.log(result.branch);
+            }
+            else {
+                console.log('sin branch');
+            }
+            // Labels
+            if (result.labels) {
+                const labels = [];
+                for (const label of result.labels) {
+                    labels.push(getColored(label, 'cyan'));
+                }
+                console.log(labels.join(' '));
+            }
+            // Body
+            if (result.body) {
+                console.log(result.body);
+            }
+            return true;
+        });
+    },
+    checkIssueType(issueNumber) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!context.projectApi) {
+                return false;
+            }
+            const issue = yield context.projectApi.getIssueObject(issueNumber);
+            // Setea el issueType segun el issue
+            try {
+                let newIssueType = 'feature';
+                if (issue.labels && ((_a = issue.labels) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+                    if (issue.labels.includes('documentation')) {
+                        newIssueType = 'doc';
+                    }
+                    else if (issue.labels.includes('automation')) {
+                        newIssueType = 'automation';
+                    }
+                    else if (issue.labels.includes('bug')) {
+                        newIssueType = 'fix';
+                    }
+                }
+                context.newIssueType = newIssueType;
+            }
+            catch (error) {
+                console.log(error);
+            }
+            return true;
+        });
+    }
+};

package/lib/helpers/tasks.d.ts

@@ -0,0 +1,12 @@
+import { ITask } from "../types/helpers/tasks.js";
+import { AnyValue, CommandOptions, ObjectRecord } from "../types/auto.js";
+export declare const TASKS_FOLDER: string;
+export declare const SUBTASKS_FOLDER: string;
+export declare const NEW_FOLDER: string;
+export declare function getTaskFolder(command: string): string;
+export declare function getTasks(folder?: string): Record<string, ITask>;
+export declare function helpTask(task: ITask): Promise<boolean>;
+export declare function validateTask(task: ITask): boolean;
+export declare function runTask(task: ITask, taskContext: CommandOptions, tabs?: string): Promise<boolean>;
+export declare function previewTask(task: ITask, tabs?: string): Promise<void>;
+export declare function createObject(fields: ObjectRecord, values: AnyValue[]): ObjectRecord;