nitor 1.2.2 → 1.3.0

package/CHANGELOG.md

@@ -30,3 +30,11 @@ For a complete list of changes and discussion, see [Issue #1](https://github.com
 - Added time entry commands.
 
 - [Issue #5](https://github.com/codebynithin/nitor/issues/5)
+
+## [1.3.0] - 2025-11-29
+
+### New Features
+
+- Added support for task stats and get task commands.
+
+- [Issue #7](https://github.com/codebynithin/nitor/issues/7)

package/README.md

@@ -26,6 +26,9 @@ A CLI utility toolkit for automating and managing build, deploy, and status oper
 - Cleanup local git branches
 - Time entry management with Zoho integration
 - GitLab activity tracking
+- Task statistics with merge request details
+- Extract Zoho task IDs from GitLab issue descriptions
+- Merge request status tracking for active tasks
 
 ## Requirements
 
@@ -36,6 +39,7 @@ A CLI utility toolkit for automating and managing build, deploy, and status oper
   - `COOKIE` - Cookie for Gitlab (Copy from browser)
   - `GITLAB_URI` - GitLab API URL, eg: `https://gitlab.com/`
   - `GITLAB_TOKEN` - Gitlab token
+  - `GITLAB_DEFAULT_PROJECT_ID` - Default GitLab project ID for issue lookups
   - `MR_PROMPT` - Merge request prompt
   - `MR_LANG` - Merge request language
   - `AI_API_KEY` - AI API key
@@ -155,6 +159,26 @@ Once enabled, you can use Tab to autocomplete:
   ```bash
   nitor time-zoho
   ```
+- **Time Entry - GitLab Activities:**
+  ```bash
+  nitor time-gitlab -from <YYYY-MM-DD> -to <YYYY-MM-DD>
+  ```
+- **Time Entry - Merge Request Status:**
+  ```bash
+  nitor time-merge
+  ```
+- **Time Entry - Switch Project:**
+  ```bash
+  nitor time-switch
+  ```
+- **Task Stats:**
+  ```bash
+  nitor task-stats -task <task numbers with space>
+  ```
+- **Get Task (Extract Zoho Task IDs):**
+  ```bash
+  nitor get-task -task <task numbers with space>
+  ```
 
 ### Command Reference
 
@@ -178,6 +202,11 @@ Once enabled, you can use Tab to autocomplete:
 - `time-entries` : View time entries by date range
 - `time-stats` : View daily statistics of time entries
 - `time-zoho` : Sync time entries to Zoho
+- `time-gitlab` : Get GitLab activities for a date range
+- `time-merge` : View merge request status for active tasks
+- `time-switch` : Switch between default projects
+- `task-stats` : View task statistics with GitLab merge request details
+- `get-task` : Extract Zoho task IDs from GitLab issue descriptions
 
 ### Options
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nitor",
-  "version": "1.2.2",
+  "version": "1.3.0",
   "description": "A comprehensive CLI toolkit for automating GitLab operations, AI-powered code review, build/deploy automation, MongoDB backup/restore, and developer productivity tools",
   "main": "index.js",
   "author": "Nithin V <mails2nithin@gmail.com>",

package/services/cleanup.js

@@ -1,26 +1,35 @@
 const { execSync } = require('child_process');
+const os = require('os');
+const isWindows = os.platform() === 'win32';
 
 const cleanup = async () => {
   try {
     console.log('Starting cleanup process...\n');
 
+    const execOptions = { encoding: 'utf-8', shell: isWindows ? 'cmd.exe' : '/bin/sh' };
+    const execOptionsInherit = {
+      encoding: 'utf-8',
+      stdio: 'inherit',
+      shell: isWindows ? 'cmd.exe' : '/bin/sh',
+    };
+
     // Get current branch
-    const currentBranch = execSync('git branch --show-current', { encoding: 'utf-8' }).trim();
+    const currentBranch = execSync('git branch --show-current', execOptions).trim();
     console.log(`Current branch: ${currentBranch}`);
 
     // Checkout to master
     console.log('\nChecking out to master branch...');
     try {
-      execSync('git checkout master', { encoding: 'utf-8', stdio: 'inherit' });
+      execSync('git checkout master', execOptionsInherit);
     } catch (error) {
       // Try main if master doesn't exist
       console.log('Master branch not found, trying main...');
-      execSync('git checkout main', { encoding: 'utf-8', stdio: 'inherit' });
+      execSync('git checkout main', execOptionsInherit);
     }
 
     // Get all local branches except master/main
     console.log('\nFetching list of local branches...');
-    const branches = execSync('git branch', { encoding: 'utf-8' })
+    const branches = execSync('git branch', execOptions)
       .split('\n')
       .map((branch) => branch.trim().replace('* ', ''))
       .filter((branch) => branch && branch !== 'master' && branch !== 'main');
@@ -39,7 +48,7 @@ const cleanup = async () => {
 
     for (const branch of branches) {
       try {
-        execSync(`git branch -D ${branch}`, { encoding: 'utf-8' });
+        execSync(`git branch -D ${branch}`, execOptions);
         console.log(`  ✓ Deleted: ${branch}`);
         deletedCount++;
       } catch (error) {

package/services/create-branch.js

@@ -1,4 +1,6 @@
 const { execSync } = require('child_process');
+const os = require('os');
+const isWindows = os.platform() === 'win32';
 
 const createBranch = async (values) => {
   if (!values.task || !values.type || !values.description) {
@@ -20,7 +22,10 @@ const createBranch = async (values) => {
   const branchName = `${values.project}-${values.task}-${values.type}-${values.description.toLowerCase().replace(/\s/g, '-')}`;
 
   try {
-    execSync(`git checkout -b ${branchName}`, { stdio: 'inherit' });
+    execSync(`git checkout -b ${branchName}`, {
+      stdio: 'inherit',
+      shell: isWindows ? 'cmd.exe' : '/bin/sh',
+    });
   } catch (error) {
     console.error('Error creating branch:', error.message);
   }

package/services/enums/actions.enum.js

@@ -11,6 +11,8 @@ module.exports = {
     REFACTOR: 'refactor',
     REVIEW: 'review',
     VERSION: 'version',
+    TASK_STATS: 'task-stats',
+    GET_TASK: 'get-task',
 
     // Time entry commands
     TIME_INIT: 'time-init',

package/services/merge.js

@@ -1,4 +1,6 @@
 const { execSync } = require('child_process');
+const os = require('os');
+const isWindows = os.platform() === 'win32';
 
 const merge = async (values) => {
   const { source, target } = values;
@@ -12,16 +14,18 @@ const merge = async (values) => {
   try {
     console.log('Starting merge process...\n');
 
-    execSync('git checkout master', { stdio: 'inherit' });
-    execSync('git pull', { stdio: 'inherit' });
-    execSync(`git checkout ${source}`, { stdio: 'inherit' });
-    execSync('git pull', { stdio: 'inherit' });
+    const execOptions = { stdio: 'inherit', shell: isWindows ? 'cmd.exe' : '/bin/sh' };
+
+    execSync('git checkout master', execOptions);
+    execSync('git pull', execOptions);
+    execSync(`git checkout ${source}`, execOptions);
+    execSync('git pull', execOptions);
 
     for (const branch of target.split(' ')) {
-      execSync(`git checkout ${branch}`, { stdio: 'inherit' });
-      execSync('git pull', { stdio: 'inherit' });
-      execSync(`git merge ${source} --no-edit`, { stdio: 'inherit' });
-      execSync('git push', { stdio: 'inherit' });
+      execSync(`git checkout ${branch}`, execOptions);
+      execSync('git pull', execOptions);
+      execSync(`git merge ${source} --no-edit`, execOptions);
+      execSync('git push', execOptions);
     }
 
     console.log('\n✓ Merge completed successfully!');

package/services/mongodb-backup.js

@@ -1,7 +1,8 @@
 const { execSync } = require('child_process');
 const os = require('os');
+const path = require('path');
 const { backupConfig, restoreConfig } = require('./utils');
-
+const isWindows = os.platform() === 'win32';
 // ANSI color codes
 const colors = {
   red: '\x1b[31m',
@@ -12,6 +13,7 @@ const colors = {
 /**
  * Execute MongoDB restore from local backup to Docker container
  * @param {Object} config - Restore configuration
+ * @param {boolean} config.mongoInDocker - If mongodb running outside of docker
  * @param {string} config.containerName - Name of the Docker container (default: 'mongodb')
  * @param {string} config.localBackupPath - Local path where backup is stored (default: '~/backups/mongo')
  * @param {string} config.containerBackupPath - Path inside container for backup (default: '/data/backup')
@@ -19,37 +21,60 @@ const colors = {
 const executeMongoRestore = async (config) => {
   const {
     containerName = 'mongodb',
-    localBackupPath = os.homedir() + '/backups/mongo',
+    localBackupPath = path.join(os.homedir(), 'backups', 'mongo'),
     containerBackupPath = '/data/backup',
   } = config;
 
   try {
-    const expandedLocalPath = localBackupPath.replace('~', os.homedir());
-
-    console.log(`\nStarting MongoDB restore to container: ${containerName}`);
-
-    // Step 1: Copy backup from local to Docker container
-    const copyCommand = `docker cp ${expandedLocalPath} ${containerName}:${containerBackupPath}`;
-
-    console.log(`Copying backup to container...`);
-    execSync(copyCommand, { stdio: 'inherit' });
-    console.log(`${colors.green}✓ Backup copied to container${colors.reset}`);
-
-    // Step 2: Execute mongorestore inside the container
-    const restoreCommand = `docker exec -it ${containerName} mongorestore ${containerBackupPath}`;
-
-    console.log('Executing mongorestore...');
-    execSync(restoreCommand, { stdio: 'inherit' });
-    console.log(`${colors.green}✓ Mongorestore completed successfully${colors.reset}`);
-
-    // Step 3: Remove backup data from container
-    const cleanupCommand = `docker exec -it ${containerName} rm -rf ${containerBackupPath}`;
-
-    console.log('Cleaning up backup data from container...');
-    execSync(cleanupCommand, { stdio: 'inherit' });
-    console.log(`${colors.green}✓ Backup data removed from container${colors.reset}`);
-
-    console.log(`${colors.green}Restore completed successfully!${colors.reset}\n`);
+    const expandedLocalPath = localBackupPath.startsWith('~')
+      ? localBackupPath.replace('~', os.homedir())
+      : localBackupPath;
+    const normalizedLocalPath = path.normalize(expandedLocalPath);
+
+    if (config.mongoInDocker) {
+      console.log(`\nStarting MongoDB restore to container: ${containerName}`);
+
+      // Step 1: Copy backup from local to Docker container
+      // Use normalized path for Windows compatibility
+      const copyCommand = `docker cp "${normalizedLocalPath}" ${containerName}:${containerBackupPath}`;
+
+      console.log(`Copying backup to container...`);
+      execSync(copyCommand, { stdio: 'inherit', shell: isWindows ? 'cmd.exe' : '/bin/sh' });
+      console.log(`${colors.green}✓ Backup copied to container${colors.reset}`);
+
+      // Step 2: Execute mongorestore inside the container
+      // Remove -it flag for Windows compatibility (causes issues in non-interactive shells)
+      const restoreCommand = isWindows
+        ? `docker exec ${containerName} mongorestore ${containerBackupPath}`
+        : `docker exec -it ${containerName} mongorestore ${containerBackupPath}`;
+
+      console.log('Executing mongorestore...');
+      execSync(restoreCommand, { stdio: 'inherit', shell: isWindows ? 'cmd.exe' : '/bin/sh' });
+      console.log(`${colors.green}✓ Mongorestore completed successfully${colors.reset}`);
+
+      // Step 3: Remove backup data from container
+      const cleanupCommand = isWindows
+        ? `docker exec ${containerName} rm -rf ${containerBackupPath}`
+        : `docker exec -it ${containerName} rm -rf ${containerBackupPath}`;
+
+      console.log('Cleaning up backup data from container...');
+      execSync(cleanupCommand, { stdio: 'inherit', shell: isWindows ? 'cmd.exe' : '/bin/sh' });
+      console.log(`${colors.green}✓ Backup data removed from container${colors.reset}`);
+
+      console.log(`${colors.green}Restore completed successfully!${colors.reset}\n`);
+    } else {
+      console.log(`\nStarting MongoDB restore to local machine`);
+
+      console.log('Executing mongorestore...');
+      const localRestoreCommand = `mongorestore --uri="mongodb://localhost:27017/" "${normalizedLocalPath}"`;
+      execSync(localRestoreCommand, {
+        stdio: 'inherit',
+        shell: isWindows ? 'cmd.exe' : '/bin/sh',
+      });
+      console.log(`${colors.green}✓ Mongorestore completed successfully${colors.reset}`);
+
+      console.log(`${colors.green}Restore completed successfully!${colors.reset}\n`);
+    }
 
     return { success: true };
   } catch (error) {
@@ -75,29 +100,40 @@ const executeMongoBackup = async (config) => {
     password,
     database,
     backupPath = '/data/backup',
-    localBackupPath = '~/backups/mongo/',
+    localBackupPath = path.join(os.homedir(), 'backups', 'mongo'),
   } = config;
 
   try {
     console.log(`\nStarting MongoDB backup for pod: ${pod}, database: ${database}`);
 
-    const mongodumpCommand = `kubectl exec -it ${pod} -- mongodump --username ${username} --password ${password} --authenticationDatabase ${database} --db ${database} --out ${backupPath}`;
+    // Remove -it flag for Windows compatibility
+    const mongodumpCommand = isWindows
+      ? `kubectl exec ${pod} -- mongodump --username ${username} --password ${password} --authenticationDatabase ${database} --db ${database} --out ${backupPath}`
+      : `kubectl exec -it ${pod} -- mongodump --username ${username} --password ${password} --authenticationDatabase ${database} --db ${database} --out ${backupPath}`;
 
     console.log('Executing mongodump...');
-    execSync(mongodumpCommand, { stdio: 'inherit' });
+    execSync(mongodumpCommand, { stdio: 'inherit', shell: isWindows ? 'cmd.exe' : '/bin/sh' });
     console.log(`${colors.green}✓ Mongodump completed successfully${colors.reset}`);
 
-    const expandedLocalPath = localBackupPath.replace('~', os.homedir());
-    const destinationPath = `${expandedLocalPath}${database}`;
-    const copyCommand = `kubectl cp ${pod}:${backupPath}/${database} ${destinationPath}`;
-    const cleanupCommand = `kubectl exec -it ${pod} -- rm -rf ${backupPath}`;
+    // Expand and normalize paths for cross-platform compatibility
+    const expandedLocalPath = localBackupPath.startsWith('~')
+      ? localBackupPath.replace('~', os.homedir())
+      : localBackupPath;
+    const normalizedBasePath = path.normalize(expandedLocalPath);
+    const destinationPath = path.join(normalizedBasePath, database);
+
+    // Use quotes for paths with spaces on Windows
+    const copyCommand = `kubectl cp ${pod}:${backupPath}/${database} "${destinationPath}"`;
+    const cleanupCommand = isWindows
+      ? `kubectl exec ${pod} -- rm -rf ${backupPath}`
+      : `kubectl exec -it ${pod} -- rm -rf ${backupPath}`;
 
     console.log(`Copying backup to ${destinationPath}...`);
-    execSync(copyCommand, { stdio: 'inherit' });
+    execSync(copyCommand, { stdio: 'inherit', shell: isWindows ? 'cmd.exe' : '/bin/sh' });
     console.log(`${colors.green}✓ Backup copied successfully${colors.reset}`);
 
     console.log('Cleaning up backup data from pod...');
-    execSync(cleanupCommand, { stdio: 'inherit' });
+    execSync(cleanupCommand, { stdio: 'inherit', shell: isWindows ? 'cmd.exe' : '/bin/sh' });
     console.log(`${colors.green}✓ Backup data removed from pod${colors.reset}`);
 
     console.log(
@@ -159,6 +195,8 @@ const backup = async (values) => {
   console.log(`Starting restore process for projects: ${projects.join(', ')}`);
   console.log(`========================================`);
 
+  restoreConfig.mongoInDocker = !!values?.docker;
+
   await executeMongoRestore(restoreConfig);
 
   console.log('\n========================================');

package/services/process-commands.js

@@ -18,25 +18,19 @@ const { addNewTask } = require('./time-entry/add-task');
 const { updateTask, deleteTask } = require('./time-entry/update-delete-task');
 const { getGitlabActivities } = require('./time-entry/get-gitlab-activities');
 const { getZohoTasks } = require('./time-entry/get-zoho-tasks');
+const {
+  getTaskStats,
+  getGitIdStats,
+  getGitlabIssueMergeRequests,
+  getGitMergeRequestDetails,
+} = require('./task-stats');
 
 const processArgs = async (type, value) => {
   try {
     let values;
 
     // Skip convertParamsToMap for time commands and other special commands
-    const skipConversion = [
-      ACTIONS.HELP,
-      ACTIONS.VERSION,
-      ACTIONS.CLEANUP,
-      ACTIONS.TIME_ADD,
-      ACTIONS.TIME_UPDATE,
-      ACTIONS.TIME_DELETE,
-      ACTIONS.TIME_STATUS,
-      ACTIONS.TIME_ENTRIES,
-      ACTIONS.TIME_ZOHO,
-      ACTIONS.TIME_GITLAB,
-      ACTIONS.TIME_MERGE,
-    ];
+    const skipConversion = [ACTIONS.HELP, ACTIONS.VERSION, ACTIONS.CLEANUP];
 
     if (!skipConversion.includes(type) && !value?.includes('--h') && !value?.includes('-help')) {
       values = await convertParamsToMap(value, type);
@@ -292,6 +286,88 @@ ${cyan}${bold}╔═════════════════════
         break;
       }
 
+      case ACTIONS.TASK_STATS: {
+        if (value === '-help' || value === '--h') {
+          console.log(`usage: \tnu task-stats [-task <task number>]
+\tnu task-stats [-t <task number>]
+
+View task stats
+
+Options:
+  -t, --task <number>  task number`);
+
+          return;
+        }
+
+        if (!values.task) {
+          console.log('Task number is required');
+
+          process.exit(1);
+        }
+
+        const list = [];
+
+        for (const task of values.task.split(' ')) {
+          const taskDetail = await getTaskStats(task);
+          const gitIdDetails = await getGitIdStats(taskDetail.itemIds);
+          const mrDetails = await getGitlabIssueMergeRequests(gitIdDetails);
+
+          for (const mrDetail of mrDetails) {
+            list.push({
+              Task: task,
+              Owner: taskDetail.owner,
+              ...mrDetail,
+            });
+          }
+        }
+
+        console.table(list);
+
+        break;
+      }
+
+      case ACTIONS.GET_TASK: {
+        if (value === '-help' || value === '--h') {
+          console.log(`usage: \tnu get-task [-task <task numbers with space>]
+\tnu get-task [-t <task numbers with space>]
+
+Get task details
+
+Options:
+  -t, --task <numbers with space>  task numbers with space`);
+
+          return;
+        }
+
+        if (!values.task) {
+          console.log('Task number is required');
+
+          process.exit(1);
+        }
+
+        const tasks = {};
+
+        for (const task of values.task.split(' ')) {
+          const taskDetails = await getGitMergeRequestDetails(task);
+
+          if (taskDetails.error) {
+            console.log(`No merge requests found for task ${task}`);
+
+            continue;
+          }
+
+          for (const taskDetail of taskDetails) {
+            const zohoTaskMatch = taskDetail.description?.match(/itemdetails\/(I\d+)\)/);
+
+            tasks[task] = zohoTaskMatch ? zohoTaskMatch[1] : 'Not found';
+          }
+        }
+
+        console.log(tasks);
+
+        break;
+      }
+
       // Time entry commands
       case ACTIONS.TIME_ADD: {
         const timeValues = value ? removeEmpty(value?.split(' -')) : value;

package/services/task-stats.js

@@ -0,0 +1,197 @@
+const axios = require('axios');
+const { zohoConfig, gitlabConfig } = require('./utils');
+
+const getZohoUrl = (type, taskNumber) => {
+  switch (type) {
+    case 'task':
+      return `${zohoConfig.url}/zsapi/team/${zohoConfig.team}/projects/${zohoConfig.defaultProjectId}/item/no-${taskNumber}/?action=details`;
+
+    case 'gitId':
+      return `${zohoConfig.url}/zsapi/team/${zohoConfig.team}/projects/${zohoConfig.defaultProjectId}/item/${taskNumber}/scm/3/issuedetails/?action=scmissuedetails`;
+  }
+};
+
+const getZohoConfig = (type, taskNumber) => {
+  return {
+    method: 'get',
+    maxBodyLength: Infinity,
+    url: getZohoUrl(type, taskNumber),
+    headers: {
+      'User-Agent':
+        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:145.0) Gecko/20100101 Firefox/145.0',
+      Accept: '*/*',
+      'Accept-Language': 'en-GB,en;q=0.5',
+      'Accept-Encoding': 'gzip, deflate, br, zstd',
+      Referer: `${zohoConfig.url}/workspace/4medica/client/wmoku`,
+      'X-ZA-REQSIZE': 'large',
+      'X-Requested-With': 'XMLHttpRequest',
+      'X-ZA-SOURCE': zohoConfig.source,
+      'X-ZA-UI-VERSION': 'v2',
+      'X-ZCSRF-TOKEN': zohoConfig.token,
+      'X-ZA-CLIENTPORTALID': zohoConfig.portalId,
+      'X-ZA-SESSIONID': zohoConfig.sessionId,
+      Connection: 'keep-alive',
+      Cookie: zohoConfig.cookie,
+      'Sec-Fetch-Dest': 'empty',
+      'Sec-Fetch-Mode': 'cors',
+      'Sec-Fetch-Site': 'same-origin',
+      Priority: 'u=0',
+      Pragma: 'no-cache',
+      'Cache-Control': 'no-cache',
+      TE: 'trailers',
+    },
+  };
+};
+
+const getGitlabConfig = (url) => {
+  return {
+    method: 'get',
+    maxBodyLength: Infinity,
+    url,
+    headers: {
+      'User-Agent':
+        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:145.0) Gecko/20100101 Firefox/145.0',
+      Accept: 'application/json',
+      'Accept-Language': 'en-GB,en;q=0.5',
+      'Accept-Encoding': 'gzip, deflate, br, zstd',
+      'PRIVATE-TOKEN': gitlabConfig.token,
+      Connection: 'keep-alive',
+      Cookie: gitlabConfig.cookie,
+    },
+  };
+};
+
+const getTaskStats = async (task) => {
+  try {
+    const config = getZohoConfig('task', task);
+    const response = await axios.request(config);
+
+    return {
+      itemIds: response.data.itemIds,
+      owner: Object.values(response.data.userDisplayName).join(', '),
+    };
+  } catch (error) {
+    console.log(error);
+  }
+};
+
+const getGitIdStats = async (gitIds) => {
+  const gitIdStats = [];
+
+  for (const gitId of gitIds) {
+    try {
+      const config = getZohoConfig('gitId', gitId);
+      const response = await axios.request(config);
+
+      gitIdStats.push(response.data);
+    } catch (error) {
+      console.log(error);
+    }
+  }
+
+  return gitIdStats;
+};
+
+const getGitlabIssueDetails = async (projectId, issueIid) => {
+  try {
+    const config = getGitlabConfig(`${projectId}/issues/${issueIid}`);
+    const response = await axios.request(config);
+
+    return response.data;
+  } catch (error) {
+    console.error('Error fetching GitLab issue details:', error.message);
+    if (error.response) {
+      console.error('Response status:', error.response.status);
+      console.error('Response data:', error.response.data);
+    }
+    throw error;
+  }
+};
+
+const getGitMergeRequestDetails = async (issueIid, projectId) => {
+  try {
+    if (!projectId) {
+      projectId = `${gitlabConfig.url}/api/v4/projects/${gitlabConfig.defaultProjectId}`;
+    }
+
+    const config = getGitlabConfig(`${projectId}/issues/${issueIid}/related_merge_requests`);
+    const response = await axios.request(config);
+
+    return response.data;
+  } catch (error) {
+    return { error };
+  }
+};
+
+const getGitlabIssueMergeRequests = async (gitDetails) => {
+  for (const gitDetail of gitDetails) {
+    try {
+      const mergeRequests = await getGitMergeRequestDetails(
+        gitDetail.iid,
+        gitDetail._links.project,
+      );
+      const detailedMRs = await Promise.all(
+        mergeRequests.map(async (mr) => {
+          try {
+            const detailConfig = getGitlabConfig(
+              `${gitlabConfig.url}/api/v4/projects/${mr.project_id}/merge_requests/${mr.iid}`,
+            );
+            const detailResponse = await axios.request(detailConfig);
+            const mrData = detailResponse.data;
+
+            // Fetch approval details separately
+            try {
+              const approvalConfig = getGitlabConfig(
+                `${gitlabConfig.url}/api/v4/projects/${mr.project_id}/merge_requests/${mr.iid}/approvals`,
+              );
+              const approvalResponse = await axios.request(approvalConfig);
+              const approvalData = approvalResponse.data;
+
+              // Merge approval data with MR data
+              return {
+                IssueID: gitDetail.iid,
+                MRID: mrData.iid,
+                MRAssignedTo: mrData.assignee?.name,
+                Repo: mr.reference?.split('!')?.[0],
+                ApprovedBy:
+                  (approvalData.approved_by || [])
+                    .map((approvedBy) => approvedBy?.user?.name || '')
+                    ?.join(', ') || 'Not Approved',
+                ApprovedCount: approvalData.approved_by?.length || 0,
+                MergedBy: mrData.merged_by?.name || 'Not Merged',
+                MergedOn: mrData.merged_at?.split('T')?.[0] || 'Not Merged',
+              };
+            } catch (approvalError) {
+              console.error(`Error fetching approvals for MR ${mr.iid}:`, approvalError.message);
+              // Return MR data without approval details if approval fetch fails
+              return mrData;
+            }
+          } catch (error) {
+            console.error(`Error fetching details for MR ${mr.iid}:`, error.message);
+            // Return the basic MR data if detailed fetch fails
+            return mr;
+          }
+        }),
+      );
+
+      return detailedMRs;
+    } catch (error) {
+      console.error('Error fetching GitLab issue merge requests:', error.message);
+
+      if (error.response) {
+        console.error('Response status:', error.response.status);
+        console.error('Response data:', error.response.data);
+      }
+
+      throw error;
+    }
+  }
+};
+
+module.exports = {
+  getTaskStats,
+  getGitIdStats,
+  getGitlabIssueDetails,
+  getGitlabIssueMergeRequests,
+  getGitMergeRequestDetails,
+};

package/services/time-entry/get-gitlab-activities.js

@@ -2,25 +2,61 @@ const axios = require('axios');
 const cheerio = require('cheerio');
 const { gitlabConfig } = require('../utils');
 
+/**
+ * Fetches GitLab activities for a date range
+ * Defaults to last one week if no values are provided
+ * @param {Array} values - Optional array of filter values (e.g., ['-from 2024-11-21', '-to 2024-11-28'])
+ * @returns {Object} Object with dates as keys and activities grouped by action
+ */
 const getGitlabActivities = async (values) => {
   const resp = {};
+  const res = [];
   const filters = getFilters(values);
   const startDate = new Date(filters.from);
 
+  // Iterate through each date in the range
   while (startDate <= new Date(filters.to)) {
     const date = startDate.toISOString().split('T')[0];
     const activities = await getGitlabActivitiesByDate(date);
 
-    if (activities?.length) {
+    /* if (activities?.length) {
       resp[date] = arrayToObjectByKey(activities, 'action');
-    }
+    } */
+    res.push(...activities);
 
     startDate.setDate(startDate.getDate() + 1);
   }
 
-  console.log(resp);
+  // Format and display each entry in a single line with ellipses
+  const truncate = (str, maxLen = 50) => {
+    if (!str) return '';
+    return str.length > maxLen ? str.substring(0, maxLen - 3) + '...' : str;
+  };
+
+  console.log('\n📊 GitLab Activities (Last Week)\n');
+  console.log(
+    `\n${'index'.toString().padStart(8)} | ${'date'.toString().padStart(10)} ${'time'.toString().padEnd(8) || ''.padEnd(8)} | ${'action'.toString().padEnd(18)} | ${'text'.toString().padEnd(100)} | ${'project'.toString().padEnd(25)}`,
+  );
+  res.forEach((activity, index) => {
+    const { date, time, action, text, project } = activity;
+    const formattedText = truncate(text, 100);
+    const formattedAction = action?.padEnd(18) || ''.padEnd(18);
+    const formattedProject = truncate(project, 25);
+
+    console.log(
+      `${(index + 1).toString().padStart(8)} | ${date} ${time?.padEnd(8) || ''.padEnd(8)} | ${formattedAction} | ${formattedText.padEnd(100)} | ${formattedProject}`,
+    );
+  });
+  console.log(`\n✅ Total: ${res.length} activities\n`);
+
   return resp;
 };
+
+/**
+ * Parses filter values or sets default to last one week
+ * @param {Array} values - Array of filter strings
+ * @returns {Object} Object with 'from' and 'to' date strings
+ */
 const getFilters = (values) => {
   const filters = {};
   const keyMap = {
@@ -31,10 +67,12 @@ const getFilters = (values) => {
   };
 
   if (values?.length) {
+    // Parse provided filter values
     for (const item of values) {
       let [key, ...itemValues] = item.split(' ');
       const itemValue = itemValues.join(' ');
 
+      // Remove leading dash if present
       if (key.charAt(0) === '-') {
         key = key.substring(1);
       }
@@ -46,6 +84,7 @@ const getFilters = (values) => {
       }
     }
   } else {
+    // Default: last one week
     filters.from = new Date(new Date().setDate(new Date().getDate() - 7))
       .toISOString()
       .split('T')[0];
@@ -54,8 +93,13 @@ const getFilters = (values) => {
 
   return filters;
 };
+
+/**
+ * Fetches GitLab activities for a specific date
+ * @param {string} date - Date in YYYY-MM-DD format
+ * @returns {Array} Array of activity objects
+ */
 const getGitlabActivitiesByDate = async (date) => {
-  const { removeEmpty } = require('./utils');
   const gitlabUrl = `${gitlabConfig.url}/users/${gitlabConfig.userId}/calendar_activities?date=${date}`;
   const headers = {
     accept: 'application/json, text/plain, */*',
@@ -71,7 +115,6 @@ const getGitlabActivitiesByDate = async (date) => {
     'x-csrf-token': gitlabConfig.xCsrfToken,
     'x-requested-with': 'XMLHttpRequest',
   };
-  // let config = { method: 'get', maxBodyLength: Infinity, url: `${gitlabUrl}2024-5-10`, headers };
 
   try {
     const response = await axios.get(gitlabUrl, { headers });
@@ -79,45 +122,39 @@ const getGitlabActivitiesByDate = async (date) => {
     const $ = cheerio.load(response.data);
 
     // Initialize an empty array to store the JSON objects
-    let contributions = [];
+    const contributions = [];
 
     // Iterate over each list item
-    $('ul.bordered-list li').each((i, element) => {
+    $('.event-item').each((i, element) => {
       const $element = $(element);
-      const time = $element.find('span.js-localtime').text().trim();
-      const action = $element
-        .contents()
-        .filter(function () {
-          return this.nodeType === 3; // Text nodes
-        })
-        .text()
-        .trim()
-        .split(/\n/g)[0]
-        .trim();
-      const detailsArray = $element
-        .find('a')
-        .map((i, el) => {
-          return {
-            title: $(el).attr('title'),
-            href: $(el).attr('href').split(/\/-\//g)[1],
-            text: $(el).text().trim().replace(/!/g, ''),
-          };
-        })
-        .get();
-      const details = detailsArray.reduce((acc, item) => {
-        if (item.title === 'medica-portal-client') {
-          acc.repo = item.title;
-        } else {
-          acc = removeEmpty(item);
-        }
-
-        return acc;
-      }, {});
+      const time = $element.find('.event-item-timestamp').text()?.trim();
+      const action = $element.find('.event-title-block .event-type').text()?.trim();
+      const project = $element.find('.event-title-block .project-name').text()?.trim();
+      const $refLink = $element.find('.event-title-block a.ref-name');
+      const $targetLink = $element.find('.event-title-block a.event-target-link');
+
+      let href, text;
+
+      if ($refLink.length > 0) {
+        href = $refLink.attr('href');
+        text = $refLink.text()?.trim();
+      } else if ($targetLink.length > 0) {
+        href = $targetLink.attr('href');
+        text = $targetLink.text()?.trim();
+      } else {
+        const $eventTypeSpan = $element.find('.event-title-block .event-type');
+        const nextSpan = $eventTypeSpan.next('span');
+
+        text = nextSpan.text()?.trim();
+        href = undefined;
+      }
 
       contributions.push({
         time,
         action,
-        ...details,
+        text,
+        project,
+        date,
       });
     });
 
@@ -126,12 +163,5 @@ const getGitlabActivitiesByDate = async (date) => {
     console.log(error.message);
   }
 };
-const arrayToObjectByKey = (arr, key) => {
-  return arr.reduce((acc, obj) => {
-    acc[obj[key]] = obj;
-
-    return acc;
-  }, {});
-};
 
 module.exports = { getGitlabActivities };

package/services/utils.js

@@ -17,6 +17,7 @@ const gitlabConfig = {
   xCsrfToken: process.env.GITLAB_XCSRF_TOKEN,
   userId: process.env.GITLAB_USERID,
   token: process.env.GITLAB_TOKEN,
+  defaultProjectId: process.env.GITLAB_DEFAULT_PROJECT_ID,
 };
 const zohoConfig = {
   cookie: process.env.ZOHO_COOKIE,
@@ -56,6 +57,8 @@ const keyMap = {
   so: 'source',
   target: 'target',
   ta: 'target',
+  docker: 'docker',
+  do: 'docker',
 };
 const projectMap = {
   portal: 'medica-portal',
@@ -297,18 +300,16 @@ const generateDeployConfigs = (values = {}) => {
   return { configs: removeEmpty(configs, true) };
 };
 const convertParamsToMap = async (item, type) => {
-  const itemsToSkipCheck = [
-    ACTIONS.CREATE_BRANCH,
-    ACTIONS.HELP,
-    ACTIONS.VERSION,
-    ACTIONS.REFACTOR,
-    ACTIONS.BACKUP,
+  const itemsToCheckLiveness = [
+    ACTIONS.BUILD_DEPLOY,
+    ACTIONS.BUILD,
+    ACTIONS.DEPLOY,
     ACTIONS.MERGE,
+    ACTIONS.REVIEW,
   ];
-  const skipCheck = itemsToSkipCheck.includes(type);
   let live = false;
 
-  if (!skipCheck) {
+  if (itemsToCheckLiveness.includes(type)) {
     if (!gitlabConfig.token) {
       console.log('Configurations are missing...!');
       return null;

package/services/time-entry/enums/actions.enum.js

@@ -1,16 +0,0 @@
-module.exports = {
-  ACTIONS: {
-    INIT: 'init',
-    SWITCH: 'switch',
-    ADD: 'add',
-    UPDATE: 'update',
-    DELETE: 'delete',
-    STATUS: 'status',
-    ENTRIES: 'entries',
-    ZOHO: 'zoho',
-    GITLAB: 'gitlab',
-    MERGE: 'merge',
-    VERSION: 'version',
-    HELP: 'help',
-  },
-};