nitor 1.2.2 → 1.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nitor",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "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/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

@@ -24,19 +24,7 @@ const processArgs = async (type, value) => {
     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);

package/services/utils.js

@@ -56,6 +56,8 @@ const keyMap = {
   so: 'source',
   target: 'target',
   ta: 'target',
+  docker: 'docker',
+  do: 'docker',
 };
 const projectMap = {
   portal: 'medica-portal',
@@ -304,6 +306,14 @@ const convertParamsToMap = async (item, type) => {
     ACTIONS.REFACTOR,
     ACTIONS.BACKUP,
     ACTIONS.MERGE,
+    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 skipCheck = itemsToSkipCheck.includes(type);
   let live = false;