gitfleet 1.0.1 → 1.0.2

package/bin/gitfleet.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 const { Command } = require("commander");
 
@@ -8,30 +8,60 @@ const status = require("../commands/status");
 const pull = require("../commands/pull");
 const exec = require("../commands/exec");
 const scan = require("../commands/scan");
-const list  = require("../commands/list")
-const branch  = require("../commands/branch")
-
+const list = require("../commands/list");
+const branch = require("../commands/branch");
+const fetch = require("../commands/fetch");
 
 const program = new Command();
 
 program
-.name("gitfleet")
-.description("Manage multiple git repositories");
+  .name("gitfleet")
+  .description("Manage multiple git repositories")
+  .version("1.0.0");
 
-program.command("init").action(init);
+program
+  .command("init")
+  .option("--scan", "Scan workspace for git repos")
+  .action((options) => init(options));
 
-program.command("add <path>").action(add);
+program
+  .command("add <path>")
+  .description("Add repository to fleet")
+  .action(add);
 
-program.command("status").action(status);
+program
+  .command("status")
+  .description("Show repo status")
+  .action(status);
 
-program.command("pull").action(pull);
+program
+  .command("pull")
+  .description("Pull all repositories")
+  .action(pull);
 
-program.command("scan <path>").action(scan);
+program
+  .command("scan <path>")
+  .description("Scan directory for git repositories")
+  .action(scan);
 
-program.command("exec <command>").action(exec)
+program
+  .command("exec <command>")
+  .description("Run command across all repos")
+  .action(exec);
 
-program.command("list").action(list)
+program
+  .command("list")
+  .description("List all repos in fleet")
+  .action(list);
 
-program.command("branch").action(branch)
+program
+  .command("branch")
+  .description("Show branches across repos")
+  .action(branch);
+
+program
+  .command("fetch")
+  .description("Fetch updates from all repos")
+  .action(fetch);
 
 program.parse();

package/commands/fetch.js

@@ -0,0 +1,21 @@
+const { loadConfig } = require("../core/config");
+
+const { execSync } = require("child_process");
+
+
+
+module.exports = function () {
+
+    const config = loadConfig();
+
+    for(const repo of config.repos){
+        try{
+
+            console.log(`\n▶ Running Fetch in ${repo}`);
+
+            execSync("git fetch", { cwd: repo, stdio: "inherit" });
+        }catch(e){
+            console.log("Error:",e)
+        }
+    }
+}

package/commands/init.js

@@ -1,10 +1,31 @@
-const { saveConfig, configFile } = require("../core/config");
+const fs = require("fs");
+const path = require("path");
 
-module.exports = function () {
+const scan = require("./scan");
 
-  saveConfig({ repos: [] });
+function init(args = []) {
 
-  console.log("GitFleet initialized");
-  console.log("Config file:", configFile);
+  const dir = path.join(process.cwd(), ".gitfleet");
 
-};
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir);
+  }
+
+  const configPath = path.join(dir, "config.json");
+
+  if (!fs.existsSync(configPath)) {
+    fs.writeFileSync(
+      configPath,
+      JSON.stringify({ repos: [] }, null, 2)
+    );
+  }
+
+  console.log("✔ GitFleet workspace initialized");
+
+  if (args.includes("--scan")) {
+    console.log("\n🔎 Scanning for git repositories...\n");
+    scan(process.cwd());
+  }
+}
+
+module.exports = init;

package/commands/pull.js

@@ -1,29 +1,26 @@
-const { loadConfig } = require("../core/config");
-const { execSync } = require("child_process");
+const { runWorkerPool } = require("../core/workerPool");
+const { exec } = require("child_process");
 
-function isRepoDirty(repo) {
-
-  const status = execSync("git status --porcelain", { cwd: repo })
-    .toString()
-    .trim();
-
-  return status.length > 0;
+function runGit(repo, command) {
+  return new Promise((resolve, reject) => {
+    exec(`git -C "${repo}" ${command}`, (err, stdout, stderr) => {
+      if (err) {
+        console.error(`❌ ${repo}`);
+        return reject(err);
+      }
 
+      console.log(`✔ ${repo}`);
+      resolve(stdout);
+    });
+  });
 }
 
-module.exports = function () {
-  const config = loadConfig();
-  for (const repo of config.repos) {
-    try {
-      if (isRepoDirty(repo)) {
-        console.log(`⚠ Skipping ${repo} (local changes)`);
-        continue;
-      }
-      console.log(`⬇ Pulling ${repo}`);
-      execSync("git pull", { cwd: repo, stdio: "inherit" });
-    } catch (err) {
-      console.log(`Failed for ${repo}`);
-    }
-  }
+async function pullRepos(repos) {
+  await runWorkerPool(
+    repos,
+    (repo) => runGit(repo, "pull"),
+    4
+  );
+}
 
-};
+module.exports = pullRepos;

package/commands/scan.js

@@ -11,10 +11,9 @@ function findRepos(dir, repos = []) {
 
     const fullPath = path.join(dir, item.name);
 
-    // if .git folder found
     if (item.name === ".git") {
-      repos.push(dir);
-      continue;
+    repos.push(dir);
+    return repos;
     }
 
     if (item.isDirectory() && item.name !== "node_modules") {

package/core/config.js

@@ -1,28 +1,45 @@
 const fs = require("fs");
-const os = require("os");
 const path = require("path");
+const os = require("os");
 
-const configDir = path.join(os.homedir(), ".gitfleet");
-const configFile = path.join(configDir, "config.json");
+function findWorkspaceConfig(start = process.cwd()) {
+  let dir = start;
 
-function loadConfig() {
-  if (!fs.existsSync(configFile)) {
-    return { repos: [] };
+  while (dir !== path.dirname(dir)) {
+    const configDir = path.join(dir, ".gitfleet");
+
+    if (fs.existsSync(configDir)) {
+      return path.join(configDir, "config.json");
+    }
+
+    dir = path.dirname(dir);
   }
 
-  return JSON.parse(fs.readFileSync(configFile));
+  return null;
+}
+
+function globalConfigPath() {
+  return path.join(os.homedir(), ".gitfleet", "config.json");
 }
 
-function saveConfig(config) {
-  if (!fs.existsSync(configDir)) {
-    fs.mkdirSync(configDir);
+function loadConfig() {
+  const workspace = findWorkspaceConfig();
+
+  if (workspace && fs.existsSync(workspace)) {
+    return JSON.parse(fs.readFileSync(workspace));
+  }
+
+  const global = globalConfigPath();
+
+  if (fs.existsSync(global)) {
+    return JSON.parse(fs.readFileSync(global));
   }
 
-  fs.writeFileSync(configFile, JSON.stringify(config, null, 2));
+  return { repos: [] };
 }
 
 module.exports = {
   loadConfig,
-  saveConfig,
-  configFile,
+  findWorkspaceConfig,
+  globalConfigPath
 };

package/core/workerPool.js

@@ -0,0 +1,22 @@
+const pLimit = require("p-limit");
+
+const os = require("os");
+const workers = os.cpus().length * 2;
+
+/**
+ * Run tasks in parallel with limited concurrency
+ * @param {Array} items - list of items (repos)
+ * @param {Function} task - async function to run per item
+ * @param {number} workers - number of parallel workers
+ */
+async function runWorkerPool(items, task, workers=4) {
+  const limit = pLimit(workers);
+
+  const tasks = items.map(item =>
+    limit(() => task(item))
+  );
+
+  return Promise.allSettled(tasks);
+}
+
+module.exports = { runWorkerPool };

package/package.json

@@ -1,23 +1,26 @@
 {
   "name": "gitfleet",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
-  "keywords": ["git",
+  "keywords": [
+    "git",
     "cli",
     "developer-tools",
-    "git-manager"],
+    "git-manager"
+  ],
   "description": "",
   "dependencies": {
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
-    "ora": "^9.3.0"
+    "ora": "^9.3.0",
+    "p-limit": "^7.3.0"
   },
   "bin": {
-  "gitfleet": "./bin/gitfleet.js"
+    "gitfleet": "./bin/gitfleet.js"
   },
-"author": "Kartik Singla",
+  "author": "Kartik Singla",
   "license": "MIT"
 }

package/readme.md

@@ -1,56 +1,262 @@
 # GitFleet
 
-Manage multiple Git repositories from a single command.
+GitFleet is a CLI tool to **manage multiple Git repositories from one place**.
 
-Stop manually pulling, pushing, and checking repos one by one.
+It allows developers working with many repositories (microservices, multi-repo projects, etc.) to run Git commands across all repositories quickly.
 
-GitFleet lets you manage your entire repo fleet in seconds.
+---
 
-## Features
+# Features
 
-- Add multiple repositories
-- Run commands across all repos
-- Pull/push everything instantly
-- Clean CLI output
-- Lightweight config system
+* Manage multiple Git repositories as a **fleet**
+* Pull updates across all repos
+* Check repository status
+* Run commands across multiple repos
+* Automatically scan and detect Git repositories
+* Workspace-based configuration
 
-## Install
+---
 
+# Installation
+
+Install GitFleet globally using npm:
+
+```bash
 npm install -g gitfleet
+```
 
-## Usage
+Verify installation:
 
-Add repository
+```bash
+gitfleet --version
+```
 
-gitfleet add /path/to/repo
+---
 
-Pull all repos
+# Workspace Configuration
 
-gitfleet pull
+GitFleet stores repository information in a **workspace configuration file**.
+
+```
+.gitfleet/config.json
+```
+
+Example:
+
+```json
+{
+  "repos": [
+    "./auth-service",
+    "./payment-service",
+    "./dashboard"
+  ]
+}
+```
+
+This file tracks all repositories that belong to the fleet.
+
+---
+
+# Getting Started
+
+Navigate to a directory that contains your repositories.
+
+Example:
+
+```bash
+cd ~/projects/microservices
+```
+
+Initialize GitFleet workspace:
+
+```bash
+gitfleet init
+```
+
+This creates:
+
+```
+.gitfleet/config.json
+```
+
+---
+
+# Automatically Scan Repositories
+
+To automatically detect Git repositories in your workspace:
 
-Push all repos
+```bash
+gitfleet init --scan
+```
 
-gitfleet push
+or
 
-List repos
+```bash
+gitfleet scan .
+```
 
+Example output:
+
+```
+✔ GitFleet workspace initialized
+
+Scanning workspace...
+
+Added: auth-service
+Added: payment-service
+Added: dashboard
+```
+
+---
+
+# List Repositories
+
+Show all repositories in the fleet:
+
+```bash
 gitfleet list
+```
+
+Example output:
+
+```
+auth-service
+payment-service
+dashboard
+```
+
+---
+
+# Pull All Repositories
+
+Pull updates across every repository:
+
+```bash
+gitfleet pull
+```
+
+This runs:
+
+```
+git pull
+```
+
+in every repository in the fleet.
+
+---
 
-## Example
+# Check Repository Status
 
-Managing 20+ microservices becomes easy:
+```bash
+gitfleet status
+```
+
+Example output:
+
+```
+auth-service      ✔ clean
+payment-service   ⚠ uncommitted changes
+dashboard         ↓ 2 commits behind
+```
+
+---
+
+# Execute Commands Across Repositories
+
+Run any command across all repositories.
+
+Example:
+
+```bash
+gitfleet exec "npm install"
+```
+
+Another example:
+
+```bash
+gitfleet exec "git checkout main"
+```
+
+---
+
+# Fetch Updates
+
+Fetch updates from all repositories without merging.
+
+```bash
+gitfleet fetch
+```
+
+---
+
+# Show Current Branch
+
+Display the active branch of each repository:
+
+```bash
+gitfleet branch
+```
+
+Example output:
+
+```
+auth-service      main
+payment-service   develop
+dashboard         main
+```
+
+---
+
+# Add Repository Manually
+
+Add a repository manually to the fleet.
+
+```bash
+gitfleet add ../new-service
+```
+
+---
+
+# Example Workflow
+
+Typical workflow for a developer managing multiple repositories:
+
+```bash
+cd ~/projects/microservices
+
+gitfleet init --scan
 
 gitfleet pull
+
 gitfleet status
-gitfleet push
 
-## Why GitFleet?
+gitfleet exec "npm install"
+```
+
+---
+
+# Example Project Structure
+
+```
+microservices/
+   .gitfleet/
+      config.json
+
+   auth-service/
+   payment-service/
+   dashboard/
+```
+
+---
+
+# Why GitFleet?
+
+Developers working with microservices or multiple repositories often run the same commands repeatedly.
 
-Developers working with multiple repositories waste time repeating commands.
+GitFleet helps automate those workflows and manage repositories as a single fleet.
 
-GitFleet automates it.
+---
 
-## Author
+# License
 
-Kartik Singla
-Full-Stack / Web3 Developer
+MIT