nitor 1.3.2 → 1.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nitor",
-  "version": "1.3.2",
+  "version": "1.3.4",
   "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

@@ -15,15 +15,15 @@ const cleanup = async () => {
 
     // Get current branch
     const currentBranch = execSync('git branch --show-current', execOptions).trim();
-    console.log(`Current branch: ${currentBranch}`);
 
-    // Checkout to master
+    console.log(`Current branch: ${currentBranch}`);
     console.log('\nChecking out to master branch...');
     try {
       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', execOptionsInherit);
     }
 
@@ -40,28 +40,32 @@ const cleanup = async () => {
     }
 
     console.log(`\nFound ${branches.length} branch(es) to delete:`);
-
-    // Delete each branch
     console.log('\nDeleting branches...');
+
     let deletedCount = 0;
     let failedCount = 0;
 
     for (const branch of branches) {
       try {
         execSync(`git branch -D ${branch}`, execOptions);
-        console.log(`  ✓ Deleted: ${branch}`);
+        execSync(`rm -rf ~/.git/logs/refs/heads/${branch}`, execOptions);
+        execSync(`rm -rf ~/.git/refs/heads/${branch}`, execOptions);
+
+        console.log(`Deleted: ${branch}`);
+
         deletedCount++;
       } catch (error) {
-        console.log(`  ✗ Failed to delete: ${branch}`);
+        console.log(`Failed to delete: ${branch}`);
+
         failedCount++;
       }
     }
 
     console.log(`\nCleanup complete!`);
-    console.log(`  Deleted: ${deletedCount} branch(es)`);
+    console.log(`Deleted: ${deletedCount} branch(es)`);
 
     if (failedCount > 0) {
-      console.log(`  Failed: ${failedCount} branch(es)`);
+      console.log(`Failed: ${failedCount} branch(es)`);
     }
   } catch (error) {
     console.error('Error during cleanup:', error.message);

package/services/process-commands.js

@@ -2,7 +2,7 @@ const axios = require('axios');
 const { build, buildStatus } = require('./build');
 const { deploy } = require('./deploy');
 const { ACTIONS } = require('./enums/actions.enum');
-const { convertParamsToMap, wait } = require('./utils');
+const { convertParamsToMap, wait, printTable, createSpinner } = require('./utils');
 const { createBranch } = require('./create-branch');
 const { mrAIReview } = require('./review');
 const { refactor } = require('./refactor');
@@ -299,46 +299,59 @@ Options:
           return;
         }
 
-        if (values.sprint) {
-          const sprints = await getSprints({ params: {} });
-          const taskDetails = await getZohoTasks({
-            params: { sprint: sprints.find(({ label }) => label === values.sprint)?.value },
-          });
+        const spinner = createSpinner('Fetching task statistics');
+        spinner.start();
 
-          values.task = taskDetails.map(({ taskId }) => taskId);
-        } else {
-          values.task = values.task.split(' ');
-        }
+        try {
+          if (values.sprint) {
+            spinner.update('Loading sprints');
+            const sprints = await getSprints({ params: {} });
+            const taskDetails = await getZohoTasks({
+              params: { sprint: sprints.find(({ label }) => label.includes(values.sprint))?.value },
+            });
 
-        // Process all tasks in parallel
-        const taskResults = await Promise.all(
-          values.task.map(async (task) => {
-            const taskDetail = await getTaskStats(task);
+            values.task = taskDetails.map(({ taskId }) => taskId);
+          } else {
+            values.task = values.task.split(' ');
+          }
 
-            if (!taskDetail?.itemIds) {
-              return [];
-            }
+          spinner.update(`Processing ${values.task.length} task(s)`);
 
-            const gitIdDetails = await getGitIdStats(taskDetail.itemIds);
+          // Process all tasks in parallel
+          const taskResults = await Promise.all(
+            values.task.map(async (task) => {
+              const taskDetail = await getTaskStats(task);
 
-            if (!gitIdDetails?.length) {
-              return [];
-            }
+              if (!taskDetail?.itemIds) {
+                return [];
+              }
 
-            const mrDetails = await getGitlabIssueMergeRequests(gitIdDetails);
+              const gitIdDetails = await getGitIdStats(taskDetail.itemIds);
 
-            return mrDetails.map((mrDetail) => ({
-              Task: task,
-              Owner: taskDetail.owner,
-              ...mrDetail,
-            }));
-          }),
-        );
+              if (!gitIdDetails?.length) {
+                return [];
+              }
 
-        // Flatten the results
-        const list = taskResults.flat();
+              const mrDetails = await getGitlabIssueMergeRequests(gitIdDetails);
 
-        console.table(list);
+              return mrDetails.map((mrDetail) => ({
+                Task: task,
+                Owner: taskDetail.owner,
+                ...mrDetail,
+              }));
+            }),
+          );
+
+          // Flatten the results
+          const list = taskResults.flat();
+
+          spinner.stop(`Found ${list.length} merge request(s)`, list.length > 0);
+
+          printTable(list);
+        } catch (error) {
+          spinner.stop('Failed to fetch task statistics', false);
+          throw error;
+        }
 
         break;
       }
@@ -421,7 +434,7 @@ Options:
       case ACTIONS.TIME_ENTRIES: {
         const timeValues = value ? value.split(' -') : value;
 
-        console.table(await getTasksByDate(timeValues));
+        printTable(await getTasksByDate(timeValues));
 
         break;
       }
@@ -485,7 +498,7 @@ Options:
           }),
         );
 
-        console.table(
+        printTable(
           mergeRequests.map((mr) => ({
             'Task ID': mr.taskId,
             'MR IID': mr.gitlabIid,
@@ -562,6 +575,8 @@ Running 'nitor help' will list available subcommands and provide some conceptual
         return;
       }
     }
+
+    process.exit(1);
   } catch (error) {
     console.log(error);
     process.exit(1);

package/services/task-stats.js

@@ -84,7 +84,9 @@ const getGitIdStats = async (gitIds) => {
       const response = await axios.request(config);
 
       gitIdStats.push(response.data);
-    } catch (error) {}
+    } catch (error) {
+      // Silently skip git IDs that fail to fetch - they may not exist or be inaccessible
+    }
   }
 
   return gitIdStats;
@@ -153,8 +155,9 @@ const getGitlabIssueMergeRequests = async (gitDetails) => {
 
               // Merge approval data with MR data
               return {
-                IssueID: gitDetail.iid,
+                GitID: gitDetail.iid,
                 MRID: mrData.iid,
+                MRStatus: mrData.state,
                 MRAssignedTo: mrData.assignee?.name,
                 MRTarget: mrData.target_branch,
                 Repo: mr.reference?.split('!')?.[0],
@@ -162,7 +165,7 @@ const getGitlabIssueMergeRequests = async (gitDetails) => {
                   (approvalData.approved_by || [])
                     .map((approvedBy) => approvedBy?.user?.name || '')
                     ?.join(', ') || 'Not Approved',
-                ApprovedCount: approvalData.approved_by?.length || 0,
+                Approvals: approvalData.approved_by?.length || 0,
                 MergedBy: mrData.merged_by?.name || 'Not Merged',
                 MergedOn: mrData.merged_at?.split('T')?.[0] || 'Not Merged',
               };

package/services/utils.js

@@ -353,6 +353,253 @@ const convertParamsToMap = async (item, type) => {
   }, {});
 };
 
+// ANSI color codes for table
+const colors = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  cyan: '\x1b[36m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  magenta: '\x1b[35m',
+  blue: '\x1b[34m',
+  white: '\x1b[37m',
+  bgBlue: '\x1b[44m',
+  bgCyan: '\x1b[46m',
+};
+
+// Unicode box-drawing characters
+const box = {
+  topLeft: '╭',
+  topRight: '╮',
+  bottomLeft: '╰',
+  bottomRight: '╯',
+  horizontal: '─',
+  vertical: '│',
+  teeDown: '┬',
+  teeUp: '┴',
+  teeRight: '├',
+  teeLeft: '┤',
+  cross: '┼',
+};
+
+// Loading spinner frames
+const spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+/**
+ * Create a loading spinner for async operations
+ * @param {string} message - Loading message to display
+ * @returns {Object} Spinner controller with start() and stop(finalMessage) methods
+ */
+const createSpinner = (message = 'Loading') => {
+  let frameIndex = 0;
+  let interval = null;
+  let isSpinning = false;
+
+  const start = () => {
+    if (isSpinning) return;
+    isSpinning = true;
+    process.stdout.write('\x1b[?25l'); // Hide cursor
+
+    interval = setInterval(() => {
+      const frame = spinnerFrames[frameIndex];
+      process.stdout.write(`\r${colors.cyan}${frame}${colors.reset} ${message}...`);
+      frameIndex = (frameIndex + 1) % spinnerFrames.length;
+    }, 80);
+  };
+
+  const stop = (finalMessage = null, success = true) => {
+    if (!isSpinning) return;
+    isSpinning = false;
+
+    if (interval) {
+      clearInterval(interval);
+      interval = null;
+    }
+
+    process.stdout.write('\x1b[?25h'); // Show cursor
+    process.stdout.write('\r\x1b[K'); // Clear line
+
+    if (finalMessage) {
+      const icon = success
+        ? `${colors.green}✔${colors.reset}`
+        : `${colors.yellow}✖${colors.reset}`;
+      console.log(`${icon} ${finalMessage}`);
+    }
+  };
+
+  const update = (newMessage) => {
+    message = newMessage;
+  };
+
+  return { start, stop, update };
+};
+
+/**
+ * Print a beautiful CLI table
+ * @param {Array<Object>} data - Array of objects to display
+ * @param {Object} options - Configuration options
+ * @param {number} options.maxColWidth - Maximum column width (default: 20)
+ * @param {Array<string>} options.columns - Specific columns to display (default: all)
+ * @param {boolean} options.sort - Whether to sort by first column (default: true)
+ * @param {string} options.sortBy - Column to sort by (default: first column)
+ * @param {string} options.sortOrder - 'asc' or 'desc' (default: 'asc')
+ */
+const printTable = (data, options = {}) => {
+  if (!data || !Array.isArray(data) || data.length === 0) {
+    console.log(`${colors.yellow}No data to display${colors.reset}`);
+    return;
+  }
+
+  // Filter out undefined/null entries
+  let filteredData = data.filter((item) => item != null);
+
+  if (filteredData.length === 0) {
+    console.log(`${colors.yellow}No data to display${colors.reset}`);
+    return;
+  }
+
+  const { maxColWidth = 20, sort = true, sortOrder = 'asc' } = options;
+
+  // Get all columns from the data
+  const allColumns = [...new Set(filteredData.flatMap((row) => Object.keys(row)))];
+  const columns = options.columns || allColumns;
+
+  // Sort data by first column (or specified column)
+  const sortBy = options.sortBy || columns[0];
+  if (sort && sortBy) {
+    filteredData = [...filteredData].sort((a, b) => {
+      const valA = a[sortBy] ?? '';
+      const valB = b[sortBy] ?? '';
+
+      // Try numeric comparison first
+      const numA = Number(valA);
+      const numB = Number(valB);
+      if (!isNaN(numA) && !isNaN(numB)) {
+        return sortOrder === 'asc' ? numA - numB : numB - numA;
+      }
+
+      // Fall back to string comparison
+      const strA = String(valA).toLowerCase();
+      const strB = String(valB).toLowerCase();
+      if (sortOrder === 'asc') {
+        return strA.localeCompare(strB);
+      }
+      return strB.localeCompare(strA);
+    });
+  }
+
+  // Calculate column widths
+  const colWidths = {};
+  columns.forEach((col) => {
+    const headerLen = col.length;
+    const maxDataLen = Math.max(
+      ...filteredData.map((row) => String(row[col] ?? '').length),
+      headerLen,
+    );
+    colWidths[col] = Math.min(maxDataLen, maxColWidth);
+  });
+
+  // Helper to truncate and pad text
+  const formatCell = (text, width) => {
+    const str = String(text ?? '');
+    if (str.length > width) {
+      return str.substring(0, width - 2) + '..';
+    }
+    return str.padEnd(width);
+  };
+
+  // Top border
+  let topBorder = colors.cyan + box.topLeft;
+  columns.forEach((col, i) => {
+    topBorder += box.horizontal.repeat(colWidths[col] + 2);
+    topBorder += i < columns.length - 1 ? box.teeDown : box.topRight;
+  });
+  topBorder += colors.reset;
+
+  // Header row
+  let headerRow = colors.cyan + box.vertical + colors.reset;
+  columns.forEach((col) => {
+    const sortIndicator = sort && col === sortBy ? (sortOrder === 'asc' ? ' ↑' : ' ↓') : '';
+    headerRow +=
+      ' ' +
+      colors.bold +
+      colors.yellow +
+      formatCell(col + sortIndicator, colWidths[col]) +
+      colors.reset +
+      ' ' +
+      colors.cyan +
+      box.vertical +
+      colors.reset;
+  });
+
+  // Header separator
+  let headerSep = colors.cyan + box.teeRight;
+  columns.forEach((col, i) => {
+    headerSep += box.horizontal.repeat(colWidths[col] + 2);
+    headerSep += i < columns.length - 1 ? box.cross : box.teeLeft;
+  });
+  headerSep += colors.reset;
+
+  // Data rows
+  const dataRows = filteredData.map((row) => {
+    let dataRow = colors.cyan + box.vertical + colors.reset;
+    columns.forEach((col) => {
+      const value = row[col];
+      let cellColor = colors.white;
+
+      // Apply colors based on content
+      if (col === 'Approvals') {
+        cellColor = value >= 2 ? colors.green : value >= 1 ? colors.yellow : colors.dim;
+      } else if (col === 'MergedBy' || col === 'MergedOn') {
+        cellColor = value === 'Not Merged' ? colors.dim : colors.green;
+      } else if (col === 'ApprovedBy') {
+        cellColor = value === 'Not Approved' ? colors.dim : colors.green;
+      } else if (col === 'MRStatus') {
+        cellColor =
+          value === 'merged' ? colors.green : value === 'opened' ? colors.yellow : colors.dim;
+      } else if (col === 'Task' || col === 'MRID' || col === 'GitID') {
+        cellColor = colors.cyan;
+      } else if (col === 'Owner' || col === 'MRAssignedTo') {
+        cellColor = colors.magenta;
+      } else if (col === 'Repo') {
+        cellColor = colors.blue;
+      }
+
+      dataRow +=
+        ' ' +
+        cellColor +
+        formatCell(value, colWidths[col]) +
+        colors.reset +
+        ' ' +
+        colors.cyan +
+        box.vertical +
+        colors.reset;
+    });
+    return dataRow;
+  });
+
+  // Bottom border
+  let bottomBorder = colors.cyan + box.bottomLeft;
+  columns.forEach((col, i) => {
+    bottomBorder += box.horizontal.repeat(colWidths[col] + 2);
+    bottomBorder += i < columns.length - 1 ? box.teeUp : box.bottomRight;
+  });
+  bottomBorder += colors.reset;
+
+  // Print the table
+  console.log('');
+  console.log(topBorder);
+  console.log(headerRow);
+  console.log(headerSep);
+  dataRows.forEach((row) => console.log(row));
+  console.log(bottomBorder);
+  console.log(
+    `${colors.dim}  ${filteredData.length} row${filteredData.length !== 1 ? 's' : ''} total${colors.reset}`,
+  );
+  console.log('');
+};
+
 module.exports = {
   convertParamsToMap,
   generateBuildConfigs,
@@ -369,4 +616,6 @@ module.exports = {
   restoreConfig,
   zohoConfig,
   gitlabConfig,
+  printTable,
+  createSpinner,
 };