mc-gitpulse 1.0.2 → 1.0.5

package/README.md

@@ -50,7 +50,7 @@
 
 ## Screenshot
 
-![Git Diff on postgres repo](https://raw.githubusercontent.com/mchinnappan100/npmjs-images/main/gitpluse/gitpulse-demo-2.png)
+![Git Diff on postgres repo](https://raw.githubusercontent.com/mchinnappan100/npmjs-images/main/gitpluse/gitpulse-demo-3.png)
 
 
 ## 📦 Installation
@@ -80,6 +80,11 @@ gitpulse -g /path/to/repo
 # Specify git repository path
 gitpulse --git-folder /path/to/repo
 
+# or URL for the git repo
+
+gitpulse -g git-repo-url
+
+
 # Specify custom port
 gitpulse --port 8080 --git-folder /path/to/repo 
 

package/analyzer.js

@@ -0,0 +1,370 @@
+const simpleGit = require('simple-git');
+const fs = require('fs').promises;
+const path = require('path');
+
+class GitAnalyzer {
+  constructor(repoPath) {
+    this.repoPath = repoPath;
+    this.git = simpleGit(repoPath);
+  }
+
+  async analyze() {
+    const [
+      branches,
+      tags,
+      remotes,
+      status,
+      log,
+      contributors,
+      repoSize,
+      garbageInfo
+    ] = await Promise.all([
+      this.getBranches(),
+      this.getTags(),
+      this.getRemotes(),
+      this.getStatus(),
+      this.getLog(),
+      this.getContributors(),
+      this.getRepoSize(),
+      this.analyzeGarbage()
+    ]);
+
+    const stats = this.calculateStats(log);
+    const health = this.assessRepoHealth(log, garbageInfo);
+
+    return {
+      branches,
+      tags,
+      remotes,
+      status,
+      commitCount: log.total,
+      recentCommits: log.all.slice(0, 50),
+      contributors,
+      stats,
+      repoSize,
+      garbageInfo,
+      health,
+      path: this.repoPath
+    };
+  }
+
+  async getBranches() {
+    const summary = await this.git.branch(['-a', '-v', '--sort=-committerdate']);
+    const current = summary.current;
+    
+    return {
+      current,
+      all: Object.entries(summary.branches).map(([name, info]) => ({
+        name,
+        current: name === current,
+        commit: info.commit,
+        label: info.label,
+        remote: name.startsWith('remotes/')
+      }))
+    };
+  }
+
+  async getTags() {
+    const tags = await this.git.tags();
+    return tags.all;
+  }
+
+  async getRemotes() {
+    const remotes = await this.git.getRemotes(true);
+    return remotes;
+  }
+
+  async getStatus() {
+    const status = await this.git.status();
+    return {
+      modified: status.modified,
+      created: status.created,
+      deleted: status.deleted,
+      renamed: status.renamed,
+      staged: status.staged,
+      conflicted: status.conflicted,
+      ahead: status.ahead,
+      behind: status.behind,
+      tracking: status.tracking,
+      isClean: status.isClean()
+    };
+  }
+
+  async getLog() {
+    const log = await this.git.log({ 
+      '--all': null,
+      '--max-count': 1000,
+      '--no-merges': null 
+    });
+    return log;
+  }
+
+  async getContributors() {
+    try {
+      const result = await this.git.raw([
+        'shortlog',
+        '-sn',
+        '--all',
+        '--no-merges'
+      ]);
+      
+      return result
+        .trim()
+        .split('\n')
+        .map(line => {
+          const match = line.trim().match(/^(\d+)\s+(.+)$/);
+          if (match) {
+            return {
+              commits: parseInt(match[1]),
+              name: match[2]
+            };
+          }
+          return null;
+        })
+        .filter(Boolean);
+    } catch (error) {
+      return [];
+    }
+  }
+
+  calculateStats(log) {
+    const commits = log.all;
+    const now = new Date();
+    const dayAgo = new Date(now - 24 * 60 * 60 * 1000);
+    const weekAgo = new Date(now - 7 * 24 * 60 * 60 * 1000);
+    const monthAgo = new Date(now - 30 * 24 * 60 * 60 * 1000);
+
+    const commitsLastDay = commits.filter(c => new Date(c.date) > dayAgo).length;
+    const commitsLastWeek = commits.filter(c => new Date(c.date) > weekAgo).length;
+    const commitsLastMonth = commits.filter(c => new Date(c.date) > monthAgo).length;
+
+    // Calculate commits per day of week
+    const dayOfWeek = [0, 0, 0, 0, 0, 0, 0];
+    const hourOfDay = new Array(24).fill(0);
+    
+    commits.forEach(commit => {
+      const date = new Date(commit.date);
+      dayOfWeek[date.getDay()]++;
+      hourOfDay[date.getHours()]++;
+    });
+
+    return {
+      total: log.total,
+      commitsLastDay,
+      commitsLastWeek,
+      commitsLastMonth,
+      dayOfWeek,
+      hourOfDay,
+      avgCommitsPerDay: (commitsLastMonth / 30).toFixed(2)
+    };
+  }
+
+  async getRepoSize() {
+    try {
+      const gitDir = path.join(this.repoPath, '.git');
+      const size = await this.getDirectorySize(gitDir);
+      return {
+        bytes: size,
+        mb: (size / 1024 / 1024).toFixed(2),
+        gb: (size / 1024 / 1024 / 1024).toFixed(3)
+      };
+    } catch (error) {
+      return { bytes: 0, mb: '0', gb: '0' };
+    }
+  }
+
+  async getDirectorySize(dirPath) {
+    let totalSize = 0;
+    
+    try {
+      const items = await fs.readdir(dirPath, { withFileTypes: true });
+      
+      for (const item of items) {
+        const itemPath = path.join(dirPath, item.name);
+        
+        if (item.isDirectory()) {
+          totalSize += await this.getDirectorySize(itemPath);
+        } else {
+          const stats = await fs.stat(itemPath);
+          totalSize += stats.size;
+        }
+      }
+    } catch (error) {
+      // Ignore errors for inaccessible files
+    }
+    
+    return totalSize;
+  }
+
+  async analyzeGarbage() {
+    try {
+      // Get count-objects info
+      const countObjects = await this.git.raw(['count-objects', '-v']);
+      const lines = countObjects.split('\n');
+      const info = {};
+      
+      lines.forEach(line => {
+        const [key, value] = line.split(':').map(s => s.trim());
+        if (key && value) {
+          info[key] = value;
+        }
+      });
+
+      const looseObjects = parseInt(info['count'] || 0);
+      const looseSize = parseFloat(info['size'] || 0);
+      const packCount = parseInt(info['packs'] || 0);
+      const packSize = parseFloat(info['size-pack'] || 0);
+
+      // Recommend GC if there are many loose objects
+      const shouldGC = looseObjects > 1000 || looseSize > 10;
+
+      return {
+        looseObjects,
+        looseSize,
+        packCount,
+        packSize,
+        shouldGC,
+        recommendation: shouldGC 
+          ? 'Run `git gc` to optimize repository performance'
+          : 'Repository is well optimized'
+      };
+    } catch (error) {
+      return {
+        looseObjects: 0,
+        looseSize: 0,
+        packCount: 0,
+        packSize: 0,
+        shouldGC: false,
+        recommendation: 'Unable to analyze'
+      };
+    }
+  }
+
+  assessRepoHealth(log, garbageInfo) {
+    const scores = [];
+    const issues = [];
+    const suggestions = [];
+
+    // Check commit frequency
+    const commits = log.all;
+    const now = new Date();
+    const weekAgo = new Date(now - 7 * 24 * 60 * 60 * 1000);
+    const recentCommits = commits.filter(c => new Date(c.date) > weekAgo).length;
+    
+    if (recentCommits > 0) {
+      scores.push(100);
+    } else {
+      scores.push(50);
+      issues.push('No commits in the last week');
+    }
+
+    // Check garbage collection
+    if (garbageInfo.shouldGC) {
+      scores.push(60);
+      issues.push('Repository needs garbage collection');
+      suggestions.push('Run: git gc --aggressive');
+    } else {
+      scores.push(100);
+    }
+
+    // Check for large pack files
+    if (garbageInfo.packSize > 100) {
+      issues.push('Large pack files detected');
+      suggestions.push('Consider using git-lfs for large files');
+    }
+
+    const avgScore = scores.reduce((a, b) => a + b, 0) / scores.length;
+    
+    let status = 'excellent';
+    if (avgScore < 90) status = 'good';
+    if (avgScore < 70) status = 'needs attention';
+    if (avgScore < 50) status = 'poor';
+
+    return {
+      score: Math.round(avgScore),
+      status,
+      issues,
+      suggestions
+    };
+  }
+
+  async getFileTree() {
+    try {
+      const result = await this.git.raw(['ls-tree', '-r', '--name-only', 'HEAD']);
+      const files = result.trim().split('\n').filter(Boolean);
+      
+      // Build tree structure
+      const tree = {};
+      
+      files.forEach(filepath => {
+        const parts = filepath.split('/');
+        let current = tree;
+        
+        parts.forEach((part, index) => {
+          if (index === parts.length - 1) {
+            // It's a file
+            if (!current._files) current._files = [];
+            current._files.push(part);
+          } else {
+            // It's a directory
+            if (!current[part]) current[part] = {};
+            current = current[part];
+          }
+        });
+      });
+      
+      return tree;
+    } catch (error) {
+      return {};
+    }
+  }
+
+  async getCommitGraph(limit = 100) {
+    try {
+      const result = await this.git.raw([
+        'log',
+        '--all',
+        '--graph',
+        '--pretty=format:%H|%P|%s|%an|%ar',
+        `--max-count=${limit}`
+      ]);
+      
+      const lines = result.split('\n');
+      const commits = [];
+      
+      lines.forEach(line => {
+        // Match graph characters: *, |, \, /, space
+        const graphMatch = line.match(/^([*|\\\/ ]+)/);
+        const graph = graphMatch ? graphMatch[1] : '';
+        const data = line.substring(graph.length);
+        
+        if (data && data.includes('|')) {
+          const parts = data.split('|');
+          if (parts.length >= 5) {
+            const [hash, parents, subject, author, date] = parts;
+            commits.push({
+              graph,
+              hash: hash.trim(),
+              parents: parents ? parents.trim().split(' ') : [],
+              subject: subject.trim(),
+              author: author.trim(),
+              date: date.trim()
+            });
+          }
+        }
+      });
+      
+      return commits;
+    } catch (error) {
+      console.error('Error getting commit graph:', error);
+      return [];
+    }
+  }
+}
+
+async function analyzeRepo(repoPath) {
+  const analyzer = new GitAnalyzer(repoPath);
+  return await analyzer.analyze();
+}
+
+module.exports = { GitAnalyzer, analyzeRepo };

package/cli.js

@@ -2,23 +2,67 @@
 
 const { program } = require('commander');
 const path = require('path');
+const fs = require('fs');
+const os = require('os');
 const chalk = require('chalk');
 const boxen = require('boxen');
+const ora = require('ora');
 const { startServer } = require('./server');
 const { analyzeRepo } = require('./analyzer');
+const simpleGit = require('simple-git');
 
 program
   .name('gitpulse')
-  .description('The ultimate Git UI - Better than SourceTree, approved by Linus')
+  .description('The ultimate Git UI' )
   .version('1.0.0');
 
+async function cloneRepository(url, targetDir) {
+  const spinner = ora('Cloning repository...').start();
+  
+  try {
+    const git = simpleGit();
+    await git.clone(url, targetDir, ['--depth', '1000']); // Limit depth for performance
+    spinner.succeed(chalk.green('Repository cloned successfully'));
+    return targetDir;
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to clone repository'));
+    throw error;
+  }
+}
+
+function isGitUrl(input) {
+  // Check if input looks like a Git URL
+  return input.startsWith('http://') || 
+         input.startsWith('https://') || 
+         input.startsWith('git@') ||
+         input.startsWith('ssh://') ||
+         input.includes('github.com') ||
+         input.includes('gitlab.com') ||
+         input.includes('bitbucket.org');
+}
+
+async function resolveGitPath(input) {
+  if (isGitUrl(input)) {
+    // It's a URL, clone it to a temp directory
+    const tempDir = path.join(os.tmpdir(), 'gitpulse-' + Date.now());
+    fs.mkdirSync(tempDir, { recursive: true });
+    
+    console.log(chalk.yellow('🌐 Remote repository detected'));
+    console.log(chalk.dim(`   Cloning to: ${tempDir}`));
+    
+    await cloneRepository(input, tempDir);
+    return tempDir;
+  } else {
+    // It's a local path
+    return path.resolve(input);
+  }
+}
+
 program
-  .option('-g, --git-folder <path>', 'Path to git repository', process.cwd())
+  .option('-g, --git-folder <path>', 'Path to git repository or Git URL', process.cwd())
   .option('-p, --port <number>', 'Port for web server', '3000')
   .option('--no-browser', 'Don\'t open browser automatically')
   .action(async (options) => {
-    const gitPath = path.resolve(options.gitFolder);
-    
     console.log(boxen(
       chalk.bold.cyan('🚀 GitPulse') + '\n\n' +
       chalk.green('The Ultimate Git Repository Analyzer') + '\n' +
@@ -31,11 +75,13 @@ program
       }
     ));
 
-    console.log(chalk.yellow('📁 Repository:'), chalk.white(gitPath));
-    console.log(chalk.yellow('🌐 Port:'), chalk.white(options.port));
-    console.log();
-
     try {
+      const gitPath = await resolveGitPath(options.gitFolder);
+      
+      console.log(chalk.yellow('📁 Repository:'), chalk.white(gitPath));
+      console.log(chalk.yellow('🌐 Port:'), chalk.white(options.port));
+      console.log();
+
       // Quick analysis
       const analysis = await analyzeRepo(gitPath);
       
@@ -54,4 +100,4 @@ program
     }
   });
 
-program.parse();
+program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mc-gitpulse",
-  "version": "1.0.2",
+  "version": "1.0.5",
   "description": "The ultimate Git UI - CLI + Web interface with advanced repository insights",
   "main": "index.js",
   "bin": {
@@ -19,9 +19,9 @@
   ],
   "author": "Mohan Chinnappan",
   "files": [
-    "server.js", "public/*"
+    "server.js", "analyzer.js", "cli.js",
+    "public/*"
   ],
-
   "license": "MIT",
   "dependencies": {
     "boxen": "^5.1.2",

package/public/index.html

@@ -3,11 +3,11 @@
 <head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>GitPulse  - Ultimate Git UI</title>
+  <title>GitPulse - Ultimate Git UI</title>
   <script src="https://cdn.tailwindcss.com"></script>
   <link rel="icon" type="image/x-icon"
         href="https://mohan-chinnappan-n5.github.io/dfv/img/mc_favIcon.ico" />
-   
+  
   <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
   <script src="https://cdn.jsdelivr.net/npm/monaco-editor@0.45.0/min/vs/loader.js"></script>
   <style>
@@ -200,7 +200,6 @@
 
     .commit-node {
       font-family: monospace;
-      white-space: pre;
     }
 
     /* Modal/Popup Styles */
@@ -429,7 +428,7 @@
     <div class="container mx-auto px-6 py-4">
       <div class="flex items-center justify-between">
         <div class="flex items-center space-x-4">
-          <h1 class="text-2xl font-bold text-blue-400">⚡ GitPulse </h1>
+          <h1 class="text-2xl font-bold text-blue-400">⚡ GitPulse</h1>
           <span class="text-sm text-gray-400 hidden sm:inline">The Ultimate Git Repository Analyzer</span>
         </div>
         <div class="flex items-center space-x-4">
@@ -1351,22 +1350,77 @@
           return;
         }
         
-        graphElement.innerHTML = graph.map(commit => {
-          const graphPart = commit.graph.replace(/\*/g, '<span class="text-yellow-400">●</span>')
-                                        .replace(/\|/g, '<span class="text-blue-400">│</span>')
-                                        .replace(/\//g, '<span class="text-green-400">╱</span>')
-                                        .replace(/\\/g, '<span class="text-purple-400">╲</span>');
+        // Clear existing content
+        graphElement.innerHTML = '';
+        
+        // Build DOM elements directly instead of using innerHTML with strings
+        graph.forEach(commit => {
+          const row = document.createElement('div');
+          row.className = 'commit-node hover:bg-gray-800 py-1 px-2 rounded flex items-start';
           
-          return `
-            <div class="commit-node hover:bg-gray-800 py-1 px-2 rounded">
-              <span class="text-gray-400">${graphPart}</span>
-              <span class="text-yellow-500 mx-2">${commit.hash.substring(0, 7)}</span>
-              <span class="text-gray-300">${escapeHtml(commit.subject)}</span>
-              <span class="text-blue-400 ml-2">(${escapeHtml(commit.author)})</span>
-              <span class="text-gray-500 ml-2">${escapeHtml(commit.date)}</span>
-            </div>
-          `;
-        }).join('');
+          // Graph column
+          const graphCol = document.createElement('div');
+          graphCol.className = 'text-gray-400 font-mono inline-block';
+          
+          // Process each character in the graph
+          const graphChars = (commit.graph || '').split('');
+          graphChars.forEach(char => {
+            const span = document.createElement('span');
+            switch(char) {
+              case '*':
+                span.className = 'text-yellow-400';
+                span.textContent = '●';
+                break;
+              case '|':
+                span.className = 'text-blue-400';
+                span.textContent = '│';
+                break;
+              case '/':
+                span.className = 'text-green-400';
+                span.textContent = '╱';
+                break;
+              case '\\':
+                span.className = 'text-purple-400';
+                span.textContent = '╲';
+                break;
+              case ' ':
+                span.innerHTML = '&nbsp;';
+                break;
+              default:
+                span.textContent = char;
+            }
+            graphCol.appendChild(span);
+          });
+          
+          // Hash column
+          const hashCol = document.createElement('span');
+          hashCol.className = 'text-yellow-500 mx-2 font-mono flex-shrink-0';
+          hashCol.textContent = commit.hash.substring(0, 7);
+          
+          // Subject column
+          const subjectCol = document.createElement('span');
+          subjectCol.className = 'text-gray-300 flex-1';
+          subjectCol.textContent = commit.subject;
+          
+          // Author column
+          const authorCol = document.createElement('span');
+          authorCol.className = 'text-blue-400 ml-2 flex-shrink-0';
+          authorCol.textContent = `(${commit.author})`;
+          
+          // Date column
+          const dateCol = document.createElement('span');
+          dateCol.className = 'text-gray-500 ml-2 whitespace-nowrap flex-shrink-0';
+          dateCol.textContent = commit.date;
+          
+          // Assemble row
+          row.appendChild(graphCol);
+          row.appendChild(hashCol);
+          row.appendChild(subjectCol);
+          row.appendChild(authorCol);
+          row.appendChild(dateCol);
+          
+          graphElement.appendChild(row);
+        });
         
         console.log(`Git graph loaded: ${graph.length} commits`);