cloudsync-cli 2026.7.1

package/src/cli/commands/status.js

@@ -0,0 +1,193 @@
+/**
+ * status.js - Show current sync status
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+
+
+const statusCommand = new Command('status')
+  .description('📊 Show current sync and repository status')
+  .option('--verbose', 'Show full details', false)
+  .option('--json', 'Output as JSON', false)
+  .option('--profile <name>', 'Config profile to check', 'default')
+  .action(async (options) => {
+    const verbose = options.verbose || process.argv.includes('--verbose');
+    const configPath = join(process.cwd(), '.cloudsync', 'config.json');
+    const statusFile = join(process.cwd(), '.cloudsync', 'status.json');
+    const stagingDir = join(process.cwd(), '.cloudsync', 'staging');
+    const indexFile = join(process.cwd(), '.cloudsync', 'history', 'index.json');
+
+    // Get workspace stats
+    const workspace = process.cwd();
+    const workspaceStats = getWorkspaceStats(workspace);
+
+    // Get sync status
+    let syncStatus = {
+      lastSync: null,
+      lastAction: null,
+      pendingChanges: false
+    };
+    if (existsSync(statusFile)) {
+      syncStatus = JSON.parse(readFileSync(statusFile, 'utf8'));
+    }
+
+    // Get staged files
+    let stagedFiles = [];
+    if (existsSync(stagingDir)) {
+      stagedFiles = readdirSync(stagingDir).filter(f => f !== 'index.json');
+    }
+
+    // Get history
+    let commitCount = 0;
+    if (existsSync(indexFile)) {
+      const history = JSON.parse(readFileSync(indexFile, 'utf8'));
+      commitCount = history.length;
+    }
+
+    // Build status object
+    const status = {
+      initialized: existsSync(configPath),
+      profile: options.profile,
+      workspace: {
+        path: workspace,
+        totalFiles: workspaceStats.totalFiles,
+        totalSize: workspaceStats.totalSize,
+        lastModified: workspaceStats.lastModified
+      },
+      sync: syncStatus,
+      versionControl: {
+        commits: commitCount,
+        stagedFiles: stagedFiles.length,
+        pendingChanges: workspaceStats.changedFiles > 0
+      },
+      timestamp: new Date().toISOString()
+    };
+
+    if (options.json) {
+      console.log(JSON.stringify(status, null, 2));
+      return;
+    }
+
+    // Display status
+    console.log(chalk.cyan('\n📊 CloudSync Status'));
+    console.log(chalk.gray('━'.repeat(60)));
+
+    // Initialization status
+    if (status.initialized) {
+      console.log(chalk.green('   ✓ ') + chalk.white('Initialized'));
+    } else {
+      console.log(chalk.red('   ✗ ') + chalk.white('Not initialized - Run: ') + chalk.cyan('cloudsync init'));
+    }
+
+    // Workspace status
+    console.log(chalk.gray('\n   📁 Workspace:'));
+    console.log(chalk.gray('   ├─ Path: ') + chalk.white(status.workspace.path));
+    console.log(chalk.gray('   ├─ Files: ') + chalk.cyan(status.workspace.totalFiles));
+    console.log(chalk.gray('   ├─ Size: ') + chalk.cyan(formatBytes(status.workspace.totalSize)));
+    console.log(chalk.gray('   └─ Last modified: ') + chalk.white(status.workspace.lastModified));
+
+    // Version control status
+    console.log(chalk.gray('\n   🔄 Version Control:'));
+    console.log(chalk.gray('   ├─ Total commits: ') + chalk.cyan(status.versionControl.commits));
+    console.log(chalk.gray('   ├─ Staged files: ') + chalk.cyan(status.versionControl.stagedFiles));
+    
+    if (status.versionControl.pendingChanges) {
+      console.log(chalk.yellow('   ├─ Changes: ') + chalk.yellow('Pending (run cloudsync stage to track)'));
+    } else {
+      console.log(chalk.green('   ├─ Changes: ') + chalk.green('None'));
+    }
+
+    // Sync status
+    console.log(chalk.gray('\n   🔗 Last Sync:'));
+    if (syncStatus.lastSync) {
+      console.log(chalk.gray('   ├─ Time: ') + chalk.white(new Date(syncStatus.lastSync).toLocaleString()));
+      console.log(chalk.gray('   ├─ Action: ') + chalk.cyan(syncStatus.lastAction || 'N/A'));
+      
+      if (syncStatus.pendingChanges) {
+        console.log(chalk.yellow('   └─ Status: ') + chalk.yellow('Local changes pending upload'));
+      } else {
+        console.log(chalk.green('   └─ Status: ') + chalk.green('In sync'));
+      }
+    } else {
+      console.log(chalk.gray('   └─ ') + chalk.yellow('No sync history'));
+    }
+
+    // Staged files detail
+    if (verbose && stagedFiles.length > 0) {
+      console.log(chalk.gray('\n   📋 Staged Files:'));
+      stagedFiles.forEach(f => {
+        console.log(chalk.gray('   + ') + chalk.green(f));
+      });
+    }
+
+    console.log(chalk.gray('━'.repeat(60)));
+
+    // Quick commands
+    console.log(chalk.cyan('\n   💡 Quick Commands:'));
+    console.log(chalk.gray('      cloudsync stage <files>  # Stage changes'));
+    console.log(chalk.gray('      cloudsync commit <msg>   # Commit staged'));
+    console.log(chalk.gray('      cloudsync upload         # Push to remote'));
+    console.log(chalk.gray('      cloudsync history        # View history'));
+  });
+
+function getWorkspaceStats(workspace) {
+  let totalFiles = 0;
+  let totalSize = 0;
+  let lastModified = new Date(0);
+
+  function scan(dir) {
+    if (!existsSync(dir)) return;
+    
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        
+        // Skip hidden dirs except .cloudsync
+        if (entry.name.startsWith('.') && entry.name !== '.cloudsync') continue;
+        
+        if (entry.isDirectory()) {
+          if (entry.name !== 'node_modules' && entry.name !== '.git') {
+            scan(fullPath);
+          }
+        } else if (entry.isFile()) {
+          try {
+            const stat = statSync(fullPath);
+            totalFiles++;
+            totalSize += stat.size;
+            if (stat.mtime > lastModified) {
+              lastModified = stat.mtime;
+            }
+          } catch (e) {
+            // Skip files we can't access
+          }
+        }
+      }
+    } catch (e) {
+      // Skip directories we can't access
+    }
+  }
+
+  scan(workspace);
+
+  return {
+    totalFiles,
+    totalSize,
+    lastModified: lastModified > new Date(0) ? lastModified.toLocaleString() : 'N/A'
+  };
+}
+
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+
+export default statusCommand;

package/src/cli/commands/sync.js

@@ -0,0 +1,255 @@
+/**
+ * sync.js - Bidirectional synchronization with conflict resolution
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { readFileSync, existsSync, writeFileSync, readdirSync, statSync } from 'fs';
+import { join, relative } from 'path';
+import { fileURLToPath } from 'url';
+import { logOperation } from '../../utils/logger.js';
+
+
+const syncCommand = new Command('sync')
+  .description('🔄 Bidirectional sync with conflict resolution')
+  .option('--strategy <type>', 'Conflict resolution: local|remote|manual', /^(local|remote|manual)$/i, 'manual')
+  .option('--watch', 'Continuous file watching mode', false)
+  .option('--interval <seconds>', 'Sync interval in seconds', (v) => parseInt(v, 10), 30)
+  .option('--verbose', 'Show detailed sync logs', false)
+  .option('--dry-run', 'Preview sync without executing', false)
+  .option('--profile <name>', 'Config profile to use', 'default')
+  .option('--include <patterns>', 'Files to sync (comma-separated)')
+  .option('--exclude <patterns>', 'Files to exclude (comma-separated)', 'node_modules,.git')
+  .action(async (options) => {
+    const verbose = options.verbose || process.argv.includes('--verbose');
+    const configPath = join(process.cwd(), '.cloudsync', 'config.json');
+    
+    if (!existsSync(configPath)) {
+      console.log(chalk.red('❌ Not initialized. Run: cloudsync init'));
+      return;
+    }
+
+    const config = JSON.parse(readFileSync(configPath, 'utf8'));
+    const profile = config.profiles[options.profile] || config.profiles[config.settings.defaultProfile];
+    
+    if (!profile) {
+      console.log(chalk.red(`❌ Profile '${options.profile}' not found`));
+      return;
+    }
+
+    console.log(chalk.cyan('\n🔄 CloudSync - Bidirectional Synchronization'));
+    console.log(chalk.gray('━'.repeat(50)));
+    console.log(chalk.white(`   Strategy: ${chalk.cyan(options.strategy)}`));
+    console.log(chalk.white(`   Interval: ${chalk.cyan(options.interval + 's')}`));
+    console.log(chalk.white(`   Watch Mode: ${chalk.cyan(options.watch ? 'ON' : 'OFF')}`));
+    console.log(chalk.gray('━'.repeat(50)));
+
+    if (verbose) {
+      console.log(chalk.gray('\n📋 Sync Configuration:'));
+      console.log(chalk.gray(`   Host: ${profile.host}`));
+      console.log(chalk.gray(`   User: ${profile.user}`));
+      console.log(chalk.gray(`   Protocol: ${profile.protocol}`));
+      console.log(chalk.gray(`   Include: ${options.include || 'all'}`));
+      console.log(chalk.gray(`   Exclude: ${options.exclude}`));
+    }
+
+    if (options.dryRun) {
+      console.log(chalk.yellow('\n🔍 Dry run mode - analyzing changes...'));
+      const changes = analyzeChanges(options, verbose);
+      displayChanges(changes, verbose);
+      return;
+    }
+
+    // Perform initial sync
+    console.log(chalk.cyan('\n🔍 Analyzing workspace...'));
+    const changes = analyzeChanges(options, verbose);
+    
+    if (changes.upload.length === 0 && changes.download.length === 0) {
+      console.log(chalk.green('\n✅ Workspace already in sync'));
+      return;
+    }
+
+    displayChanges(changes, verbose);
+
+    // Upload local changes
+    if (changes.upload.length > 0) {
+      console.log(chalk.cyan(`\n⬆️ Uploading ${changes.upload.length} changed files...`));
+      await performUpload(changes.upload, profile, options, verbose);
+    }
+
+    // Download remote changes
+    if (changes.download.length > 0) {
+      console.log(chalk.cyan(`\n⬇️ Downloading ${changes.download.length} changed files...`));
+      await performDownload(changes.download, profile, options, verbose);
+    }
+
+    // Handle conflicts
+    if (changes.conflicts.length > 0) {
+      console.log(chalk.yellow(`\n⚠️ ${changes.conflicts.length} conflicts detected`));
+      await resolveConflicts(changes.conflicts, options.strategy, verbose);
+    }
+
+    logOperation('sync', `Synced ${changes.upload.length} up / ${changes.download.length} down`);
+    console.log(chalk.green('\n✅ Sync complete!'));
+    
+    // Update sync status
+    updateSyncStatus(changes, verbose);
+  });
+
+function analyzeChanges(options, verbose) {
+  const workspace = process.cwd();
+  const excludePatterns = options.exclude.split(',').map(p => p.trim());
+  const includePatterns = options.include ? options.include.split(',').map(p => p.trim()) : null;
+  
+  const changes = {
+    upload: [],
+    download: [],
+    conflicts: [],
+    unchanged: []
+  };
+
+  function scanDirectory(dir, baseDir = dir) {
+    if (!existsSync(dir)) return;
+    
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        const relPath = relative(baseDir, fullPath);
+        
+        // Skip hidden directories except .cloudsync
+        if (entry.name === '.cloudsync' || entry.name === '.git') {
+          continue;
+        }
+
+        // Check exclusions
+        if (excludePatterns.some(p => relPath.includes(p))) {
+          continue;
+        }
+
+        if (entry.isDirectory()) {
+          scanDirectory(fullPath, baseDir);
+        } else if (entry.isFile()) {
+          // Check if included
+          if (includePatterns) {
+            if (!includePatterns.some(p => relPath.includes(p))) {
+              continue;
+            }
+          }
+          
+          changes.upload.push({
+            path: fullPath,
+            relative: relPath,
+            size: statSync(fullPath).size,
+            modified: statSync(fullPath).mtime
+          });
+        }
+      }
+    } catch (e) {
+      // Skip inaccessible directories
+    }
+  }
+
+  scanDirectory(workspace);
+
+  if (verbose) {
+    console.log(chalk.gray(`\n📊 Analysis Results:`));
+    console.log(chalk.gray(`   Files to upload: ${changes.upload.length}`));
+    console.log(chalk.gray(`   Files to download: ${changes.download.length}`));
+    console.log(chalk.gray(`   Conflicts: ${changes.conflicts.length}`));
+  }
+
+  return changes;
+}
+
+function displayChanges(changes, verbose) {
+  if (changes.upload.length > 0) {
+    console.log(chalk.cyan('\n📤 Files to upload:'));
+    changes.upload.forEach(f => {
+      const size = (f.size / 1024).toFixed(1) + ' KB';
+      console.log(chalk.gray(`   + ${f.relative} (${size})`));
+    });
+  }
+
+  if (changes.download.length > 0) {
+    console.log(chalk.cyan('\n📥 Files to download:'));
+    changes.download.forEach(f => {
+      console.log(chalk.gray(`   - ${f.relative}`));
+    });
+  }
+
+  if (changes.conflicts.length > 0) {
+    console.log(chalk.yellow('\n⚠️ Conflicts:'));
+    changes.conflicts.forEach(f => {
+      console.log(chalk.gray(`   ! ${f}`));
+    });
+  }
+}
+
+async function performUpload(files, profile, options, verbose) {
+  if (verbose) console.log(chalk.gray('\n🚀 Starting upload...'));
+  
+  // Simulate upload
+  for (const file of files) {
+    if (verbose) console.log(chalk.gray(`   Uploading: ${file.relative}`));
+    await sleep(100);
+  }
+  
+  console.log(chalk.green(`   ✅ ${files.length} files uploaded`));
+}
+
+async function performDownload(files, profile, options, verbose) {
+  if (verbose) console.log(chalk.gray('\n🚀 Starting download...'));
+  
+  // Simulate download
+  for (const file of files) {
+    if (verbose) console.log(chalk.gray(`   Downloading: ${file.relative}`));
+    await sleep(100);
+  }
+  
+  console.log(chalk.green(`   ✅ ${files.length} files downloaded`));
+}
+
+async function resolveConflicts(conflicts, strategy, verbose) {
+  console.log(chalk.cyan('\n🔧 Resolving conflicts...'));
+  
+  switch (strategy.toLowerCase()) {
+    case 'local':
+      console.log(chalk.gray('   Using local versions'));
+      break;
+    case 'remote':
+      console.log(chalk.gray('   Using remote versions'));
+      break;
+    case 'manual':
+      console.log(chalk.yellow('   Manual resolution required'));
+      conflicts.forEach(f => {
+        console.log(chalk.gray(`      - ${f}`));
+      });
+      break;
+  }
+}
+
+function updateSyncStatus(changes, verbose) {
+  const statusFile = join(process.cwd(), '.cloudsync', 'status.json');
+  const status = {
+    lastSync: new Date().toISOString(),
+    lastAction: 'sync',
+    changes: {
+      uploaded: changes.upload.length,
+      downloaded: changes.download.length,
+      conflicts: changes.conflicts.length
+    },
+    pendingChanges: changes.upload.length > 0
+  };
+  
+  writeFileSync(statusFile, JSON.stringify(status, null, 2));
+  
+  if (verbose) console.log(chalk.gray('Sync status updated'));
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+export default syncCommand;

package/src/cli/commands/unstage.js

@@ -0,0 +1,92 @@
+/**
+ * unstage.js - Remove files from staging area
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { existsSync, readdirSync, unlinkSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+
+
+const unstageCommand = new Command('unstage')
+  .description('📤 Remove files from staging area')
+  .argument('[files...]', 'Files to unstage')
+  .option('--all', 'Unstage all files', false)
+  .option('--verbose', 'Show detailed output', false)
+  .action(async (files, options) => {
+    const verbose = options.verbose || process.argv.includes('--verbose');
+    const stagingDir = join(process.cwd(), '.cloudsync', 'staging');
+    const indexFile = join(stagingDir, 'index.json');
+
+    if (!existsSync(stagingDir)) {
+      console.log(chalk.yellow('⚠️ No staging area exists'));
+      return;
+    }
+
+    const stagedFiles = readdirSync(stagingDir).filter(f => f !== 'index.json');
+
+    if (stagedFiles.length === 0) {
+      console.log(chalk.yellow('⚠️ No files are staged'));
+      return;
+    }
+
+    if (options.all) {
+      // Unstage all
+      console.log(chalk.cyan('\n📤 Unstaging all files...'));
+      
+      let count = 0;
+      stagedFiles.forEach(f => {
+        const path = join(stagingDir, f);
+        unlinkSync(path);
+        count++;
+        if (verbose) console.log(chalk.red(`   - ${f}`));
+      });
+
+      // Clear index
+      if (existsSync(indexFile)) {
+        unlinkSync(indexFile);
+      }
+
+      console.log(chalk.green(`\n✅ Unstaged ${count} file(s)`));
+    } else if (files.length > 0) {
+      // Unstage specific files
+      console.log(chalk.cyan('\n📤 Unstaging specified files...'));
+      
+      let count = 0;
+      files.forEach(f => {
+        const stagedName = f.split('/').pop();
+        const path = join(stagingDir, stagedName);
+        
+        if (existsSync(path)) {
+          unlinkSync(path);
+          count++;
+          if (verbose) console.log(chalk.red(`   - ${stagedName}`));
+        } else {
+          console.log(chalk.yellow(`   ⚠️ Not staged: ${f}`));
+        }
+      });
+
+      console.log(chalk.green(`\n✅ Unstaged ${count} file(s)`));
+    } else {
+      // Show usage
+      console.log(chalk.cyan('\n📤 CloudSync Unstage'));
+      console.log(chalk.gray('─'.repeat(40)));
+      console.log(chalk.gray('Usage:'));
+      console.log(chalk.gray('   cloudsync unstage <files...>  # Unstage specific files'));
+      console.log(chalk.gray('   cloudsync unstage --all      # Unstage all files'));
+    }
+
+    // Update index
+    const remainingFiles = readdirSync(stagingDir).filter(f => f !== 'index.json');
+    if (remainingFiles.length > 0) {
+      writeFileSync(indexFile, JSON.stringify({
+        files: remainingFiles,
+        timestamp: new Date().toISOString()
+      }, null, 2));
+    } else if (existsSync(indexFile)) {
+      unlinkSync(indexFile);
+    }
+  });
+
+export default unstageCommand;