reposizer 0.1.2 → 0.2.1

package/dist/bin/reposizer.js

@@ -10,9 +10,17 @@ program
 program
     .argument("[repositories...]", "One or more repositories in owner/repo format")
     .option("--json", "Return machine-readable JSON output")
+    .option("--analyze", "Approximate top-level directory sizes from Git tree metadata (no full clone)")
+    .option("--sort <field>", "When comparing multiple repositories: sort by size, stars, or name", "size")
     .action(async (repositories = [], options) => {
     try {
-        await (0, repo_1.runRepositoriesCommand)(repositories, Boolean(options.json));
+        const sortRaw = options.sort ?? "size";
+        if (sortRaw !== "size" &&
+            sortRaw !== "stars" &&
+            sortRaw !== "name") {
+            throw new Error('Invalid --sort. Use "size", "stars", or "name".');
+        }
+        await (0, repo_1.runRepositoriesCommand)(repositories, Boolean(options.json), Boolean(options.analyze), sortRaw);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : "Unexpected error occurred";
@@ -20,7 +28,7 @@ program
         process.exitCode = 1;
     }
 })
-    .addHelpText("after", "\nExamples:\n  reposizer openai/gym\n  reposizer openai/gym vercel/next.js\n  reposizer --json");
+    .addHelpText("after", "\nExamples:\n  reposizer openai/gym\n  reposizer vercel/next.js facebook/react\n  reposizer vercel/next.js facebook/react --sort stars\n  reposizer vercel/next.js --analyze\n  reposizer org vercel --limit 10\n  reposizer --json");
 program
     .command("org")
     .description("Scan repositories in a GitHub organization")

package/dist/src/commands/analyze.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAnalyzePayload = getAnalyzePayload;
+exports.printAnalyzeResult = printAnalyzeResult;
+exports.runAnalyzeCommand = runAnalyzeCommand;
+const tree_1 = require("../services/tree");
+const size_1 = require("../utils/size");
+function aggregateTopDirectories(tree, limit) {
+    const dirSizes = {};
+    let totalBytes = 0;
+    for (const item of tree) {
+        if (item.type !== "blob") {
+            continue;
+        }
+        const size = item.size ?? 0;
+        const path = item.path;
+        totalBytes += size;
+        const topDir = path.includes("/") ? path.split("/")[0] : "root";
+        dirSizes[topDir] = (dirSizes[topDir] ?? 0) + size;
+    }
+    const dirs = Object.entries(dirSizes)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, limit)
+        .map(([directory, bytes]) => ({ directory, bytes }));
+    return { totalBytes, dirs };
+}
+async function getAnalyzePayload(owner, repo) {
+    const { tree, truncated } = await (0, tree_1.getRepoTree)(owner, repo);
+    const { totalBytes, dirs } = aggregateTopDirectories(tree, 10);
+    return {
+        repository: `${owner}/${repo}`,
+        truncated,
+        total_bytes: totalBytes,
+        top_directories: dirs
+    };
+}
+function printAnalyzeResult(payload) {
+    if (payload.truncated) {
+        console.error("Warning: Git tree response was truncated by GitHub; directory totals may be incomplete.");
+    }
+    console.log(`Repository: ${payload.repository}`);
+    console.log(`Total (approx): ${(0, size_1.formatBytes)(payload.total_bytes)}`);
+    console.log("");
+    console.log("Top directories:");
+    console.log("----------------");
+    for (const { directory, bytes } of payload.top_directories) {
+        console.log(`${directory.padEnd(15)} ${(0, size_1.formatBytes)(bytes)}`);
+    }
+}
+async function runAnalyzeCommand(owner, repo) {
+    const payload = await getAnalyzePayload(owner, repo);
+    printAnalyzeResult(payload);
+}

package/dist/src/commands/repo.js

@@ -4,18 +4,76 @@ exports.runRepoCommand = runRepoCommand;
 exports.runRepositoriesCommand = runRepositoriesCommand;
 exports.runOrganizationCommand = runOrganizationCommand;
 const github_1 = require("../services/github");
+const analyze_1 = require("./analyze");
 const git_1 = require("../utils/git");
 const size_1 = require("../utils/size");
-function parseRepository(input) {
+function parseRepository(input, position) {
     const trimmed = input.trim();
     const match = /^([^/\s]+)\/([^/\s]+)$/.exec(trimmed);
     if (!match) {
-        throw new Error("Invalid repository format. Use owner/repo.");
+        throw new Error(`Invalid repository at position ${position}: "${input}". Use owner/repo.`);
     }
     return { owner: match[1], repo: match[2] };
 }
+function dedupeParsedArgs(items) {
+    const seen = new Set();
+    const out = [];
+    for (const item of items) {
+        const key = `${item.owner.toLowerCase()}/${item.repo.toLowerCase()}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        out.push(item);
+    }
+    return out;
+}
+function parseRepositoryArgs(inputs) {
+    const parsed = [];
+    for (let i = 0; i < inputs.length; i++) {
+        const input = inputs[i];
+        const { owner, repo } = parseRepository(input, i + 1);
+        parsed.push({ input, owner, repo });
+    }
+    return dedupeParsedArgs(parsed);
+}
+async function mapWithConcurrency(items, concurrency, mapper) {
+    if (items.length === 0) {
+        return [];
+    }
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    const workerCount = Math.min(concurrency, items.length);
+    const worker = async () => {
+        while (true) {
+            const index = nextIndex;
+            nextIndex += 1;
+            if (index >= items.length) {
+                return;
+            }
+            results[index] = await mapper(items[index], index);
+        }
+    };
+    await Promise.all(Array.from({ length: workerCount }, () => worker()));
+    return results;
+}
+const REPO_METADATA_CONCURRENCY = 4;
+const ANALYZE_FETCH_CONCURRENCY = 2;
+function sortRepoRows(rows, sort) {
+    const copy = [...rows];
+    if (sort === "size") {
+        copy.sort((a, b) => b.size_mb - a.size_mb || a.repository.localeCompare(b.repository));
+    }
+    else if (sort === "stars") {
+        copy.sort((a, b) => b.stars - a.stars || a.repository.localeCompare(b.repository));
+    }
+    else {
+        copy.sort((a, b) => a.repository.localeCompare(b.repository));
+    }
+    return copy;
+}
 async function runRepoCommand(repositoryInput, jsonOutput) {
-    const { owner, repo } = parseRepository(repositoryInput);
+    const { owner, repo } = parseRepository(repositoryInput, 1);
     const metadata = await (0, github_1.fetchRepositoryMetadata)(owner, repo);
     if (jsonOutput) {
         const payload = {
@@ -66,26 +124,51 @@ function buildPayload(repositoryInput, metadata) {
         language: metadata.language ?? "Unknown"
     };
 }
-async function runRepositoriesCommand(repositoryInputs, jsonOutput) {
+async function runRepositoriesCommand(repositoryInputs, jsonOutput, analyze = false, sort = "size") {
     const effectiveInputs = repositoryInputs.length > 0
         ? repositoryInputs
         : [(0, git_1.detectCurrentRepositoryFromGitRemote)()];
-    const results = await Promise.all(effectiveInputs.map(async (input) => {
-        const { owner, repo } = parseRepository(input);
-        const metadata = await (0, github_1.fetchRepositoryMetadata)(owner, repo);
-        return buildPayload(input, metadata);
-    }));
+    const parsedArgs = parseRepositoryArgs(effectiveInputs);
+    if (analyze) {
+        if (jsonOutput) {
+            const payloads = await mapWithConcurrency(parsedArgs, ANALYZE_FETCH_CONCURRENCY, async (item) => (0, analyze_1.getAnalyzePayload)(item.owner, item.repo));
+            console.log(JSON.stringify(payloads.length === 1 ? payloads[0] : payloads, null, 2));
+            return;
+        }
+        if (parsedArgs.length === 1) {
+            const only = parsedArgs[0];
+            await (0, analyze_1.runAnalyzeCommand)(only.owner, only.repo);
+            return;
+        }
+        const payloads = await mapWithConcurrency(parsedArgs, ANALYZE_FETCH_CONCURRENCY, async (item) => (0, analyze_1.getAnalyzePayload)(item.owner, item.repo));
+        for (let i = 0; i < payloads.length; i++) {
+            (0, analyze_1.printAnalyzeResult)(payloads[i]);
+            if (i < payloads.length - 1) {
+                console.log("");
+            }
+        }
+        return;
+    }
+    const results = await mapWithConcurrency(parsedArgs, REPO_METADATA_CONCURRENCY, async (item) => {
+        const metadata = await (0, github_1.fetchRepositoryMetadata)(item.owner, item.repo);
+        return buildPayload(item.input, metadata);
+    });
+    const sorted = sortRepoRows(results, sort);
     if (jsonOutput) {
-        console.log(JSON.stringify(results.length === 1 ? results[0] : results, null, 2));
+        console.log(JSON.stringify(sorted.length === 1 ? sorted[0] : sorted, null, 2));
         return;
     }
-    for (const result of results) {
+    if (sorted.length === 1) {
+        const result = sorted[0];
         console.log(`Repository: ${result.repository}`);
         console.log(`Size: ${(0, size_1.formatSizeFromKb)(result.size_mb * 1024)}`);
         console.log(`Stars: ${(0, size_1.formatStars)(result.stars)}`);
         console.log(`Language: ${result.language}`);
-        console.log("");
+        return;
     }
+    console.log(`Comparing ${sorted.length} repositories (sorted by ${sort}):`);
+    console.log("");
+    console.log(renderOrgTable(sorted));
 }
 async function runOrganizationCommand(organization, jsonOutput, limit) {
     const repositories = await (0, github_1.fetchOrganizationRepositories)(organization, limit);
@@ -104,5 +187,9 @@ async function runOrganizationCommand(organization, jsonOutput, limit) {
     console.log(`Organization: ${organization}`);
     console.log(`Repositories scanned: ${payload.length}`);
     console.log("");
+    if (payload.length === 0) {
+        console.log("No repositories to show. The organization may have no visible repos, or all of them may be archived or disabled.");
+        return;
+    }
     console.log(renderOrgTable(payload));
 }

package/dist/src/services/github.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHeaders = createHeaders;
+exports.getErrorMessage = getErrorMessage;
 exports.fetchRepositoryMetadata = fetchRepositoryMetadata;
 exports.fetchOrganizationRepositories = fetchOrganizationRepositories;
 function createHeaders(token) {
@@ -45,33 +47,59 @@ async function fetchRepositoryMetadata(owner, repo, token = process.env.GITHUB_T
         language: data.language
     };
 }
-async function fetchOrganizationRepositories(org, limit = 30, token = process.env.GITHUB_TOKEN) {
-    const safeLimit = Math.max(1, Math.min(limit, 100));
-    const endpoint = `https://api.github.com/orgs/${encodeURIComponent(org)}/repos?per_page=${safeLimit}&sort=updated&direction=desc`;
-    let response;
-    try {
-        response = await fetch(endpoint, {
-            method: "GET",
-            headers: createHeaders(token),
-            signal: AbortSignal.timeout(7000)
-        });
+function getOrganizationListErrorMessage(status) {
+    if (status === 404) {
+        return "Organization not found.";
     }
-    catch {
-        throw new Error("Unable to reach GitHub API. Check your network and try again.");
+    if (status === 401 || status === 403) {
+        return "Cannot access this organization’s repositories. If the org or its repos are private, set GITHUB_TOKEN. Otherwise verify rate limits and permissions.";
     }
-    if (!response.ok) {
-        if (response.status === 404) {
-            throw new Error("Organization not found.");
+    return getErrorMessage(status);
+}
+async function fetchOrganizationRepositories(org, limit = 30, token = process.env.GITHUB_TOKEN) {
+    const safeLimit = Math.max(1, Math.min(limit, 100));
+    const collected = [];
+    const perPage = 100;
+    let page = 1;
+    const maxPages = 25;
+    while (collected.length < safeLimit && page <= maxPages) {
+        const endpoint = `https://api.github.com/orgs/${encodeURIComponent(org)}/repos?per_page=${perPage}&page=${page}&sort=updated&direction=desc`;
+        let response;
+        try {
+            response = await fetch(endpoint, {
+                method: "GET",
+                headers: createHeaders(token),
+                signal: AbortSignal.timeout(7000)
+            });
         }
-        throw new Error(getErrorMessage(response.status));
+        catch {
+            throw new Error("Unable to reach GitHub API. Check your network and try again.");
+        }
+        if (!response.ok) {
+            throw new Error(getOrganizationListErrorMessage(response.status));
+        }
+        const data = (await response.json());
+        if (!Array.isArray(data) || data.length === 0) {
+            break;
+        }
+        for (const repo of data) {
+            if (repo.archived || repo.disabled) {
+                continue;
+            }
+            collected.push({
+                fullName: repo.full_name,
+                sizeKb: repo.size,
+                stargazersCount: repo.stargazers_count,
+                language: repo.language
+            });
+            if (collected.length >= safeLimit) {
+                return collected;
+            }
+        }
+        if (data.length < perPage) {
+            break;
+        }
+        page += 1;
     }
-    const data = (await response.json());
-    return data
-        .filter((repo) => !repo.archived && !repo.disabled)
-        .map((repo) => ({
-        fullName: repo.full_name,
-        sizeKb: repo.size,
-        stargazersCount: repo.stargazers_count,
-        language: repo.language
-    }));
+    return collected;
 }

package/dist/src/services/tree.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRepoTree = getRepoTree;
+const github_1 = require("./github");
+const BASE = "https://api.github.com";
+async function getRepoTree(owner, repo, token = process.env.GITHUB_TOKEN) {
+    const repoEndpoint = `${BASE}/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}`;
+    let repoResponse;
+    try {
+        repoResponse = await fetch(repoEndpoint, {
+            method: "GET",
+            headers: (0, github_1.createHeaders)(token),
+            signal: AbortSignal.timeout(5000)
+        });
+    }
+    catch {
+        throw new Error("Unable to reach GitHub API. Check your network and try again.");
+    }
+    if (!repoResponse.ok) {
+        throw new Error((0, github_1.getErrorMessage)(repoResponse.status));
+    }
+    const repoData = (await repoResponse.json());
+    const branch = repoData.default_branch;
+    if (!branch) {
+        throw new Error("GitHub API response missing default branch.");
+    }
+    const treeEndpoint = `${BASE}/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/git/trees/${encodeURIComponent(branch)}?recursive=1`;
+    let treeResponse;
+    try {
+        treeResponse = await fetch(treeEndpoint, {
+            method: "GET",
+            headers: (0, github_1.createHeaders)(token),
+            signal: AbortSignal.timeout(30_000)
+        });
+    }
+    catch {
+        throw new Error("Unable to reach GitHub API. Check your network and try again.");
+    }
+    if (!treeResponse.ok) {
+        throw new Error((0, github_1.getErrorMessage)(treeResponse.status));
+    }
+    const treeData = (await treeResponse.json());
+    return {
+        tree: treeData.tree ?? [],
+        truncated: Boolean(treeData.truncated)
+    };
+}

package/dist/src/utils/git.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectCurrentRepositoryFromGitRemote = detectCurrentRepositoryFromGitRemote;
-const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
 function parseRemoteToOwnerRepo(remoteUrl) {
     const normalized = remoteUrl.trim().replace(/\.git$/, "");
     const sshMatch = /^git@github\.com:([^/]+)\/([^/]+)$/.exec(normalized);
@@ -12,23 +13,80 @@ function parseRemoteToOwnerRepo(remoteUrl) {
     if (httpsMatch) {
         return `${httpsMatch[1]}/${httpsMatch[2]}`;
     }
+    const sshProtocolMatch = /^ssh:\/\/git@github\.com\/([^/]+)\/([^/]+)$/.exec(normalized);
+    if (sshProtocolMatch) {
+        return `${sshProtocolMatch[1]}/${sshProtocolMatch[2]}`;
+    }
     return null;
 }
+function findGitDirectory(startDir) {
+    let current = (0, node_path_1.resolve)(startDir);
+    while (true) {
+        const dotGitPath = (0, node_path_1.join)(current, ".git");
+        if ((0, node_fs_1.existsSync)(dotGitPath)) {
+            const stats = (0, node_fs_1.statSync)(dotGitPath);
+            if (stats.isDirectory()) {
+                return dotGitPath;
+            }
+            if (stats.isFile()) {
+                const fileContent = (0, node_fs_1.readFileSync)(dotGitPath, "utf8");
+                const match = /^\s*gitdir:\s*(.+)\s*$/im.exec(fileContent);
+                if (match?.[1]) {
+                    return (0, node_path_1.resolve)(current, match[1].trim());
+                }
+            }
+        }
+        const parent = (0, node_path_1.dirname)(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+}
+function getOriginRemoteUrlFromConfig(configPath) {
+    const configContent = (0, node_fs_1.readFileSync)(configPath, "utf8");
+    const lines = configContent.split(/\r?\n/);
+    let inOriginSection = false;
+    const originUrls = [];
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (line.length === 0 || line.startsWith(";") || line.startsWith("#")) {
+            continue;
+        }
+        const sectionMatch = /^\[(.+)\]$/.exec(line);
+        if (sectionMatch) {
+            inOriginSection = sectionMatch[1]?.trim() === 'remote "origin"';
+            continue;
+        }
+        if (!inOriginSection) {
+            continue;
+        }
+        const keyValueMatch = /^([A-Za-z0-9\-.]+)\s*=\s*(.+)$/.exec(line);
+        if (keyValueMatch?.[1] === "url") {
+            originUrls.push(keyValueMatch[2].trim());
+        }
+    }
+    if (originUrls.length === 0) {
+        throw new Error("No repository argument provided and no remote \"origin\" URL was found in .git/config.");
+    }
+    if (originUrls.length > 1) {
+        throw new Error("Multiple remote \"origin\" URLs were found in .git/config. Pass owner/repo explicitly.");
+    }
+    return originUrls[0];
+}
 function detectCurrentRepositoryFromGitRemote() {
-    let remoteUrl = "";
-    try {
-        remoteUrl = (0, node_child_process_1.execFileSync)("git", ["remote", "get-url", "origin"], {
-            encoding: "utf8",
-            timeout: 2000,
-            stdio: ["ignore", "pipe", "ignore"]
-        }).trim();
+    const gitDir = findGitDirectory(process.cwd());
+    if (!gitDir) {
+        throw new Error("No repository argument provided and no .git directory was found in this path.");
     }
-    catch {
-        throw new Error("No repository argument provided and no git origin remote was detected.");
+    const configPath = (0, node_path_1.join)(gitDir, "config");
+    if (!(0, node_fs_1.existsSync)(configPath)) {
+        throw new Error("Found .git directory but no config file. Pass owner/repo explicitly.");
     }
+    const remoteUrl = getOriginRemoteUrlFromConfig(configPath);
     const ownerRepo = parseRemoteToOwnerRepo(remoteUrl);
     if (!ownerRepo) {
-        throw new Error("Unable to parse git remote. Expected a GitHub origin remote URL.");
+        throw new Error("Unable to parse origin remote from .git/config. Expected a GitHub URL.");
     }
     return ownerRepo;
 }

package/dist/src/utils/size.js

@@ -1,8 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatBytes = formatBytes;
 exports.formatSizeFromKb = formatSizeFromKb;
 exports.kbToMbRounded = kbToMbRounded;
 exports.formatStars = formatStars;
+function formatBytes(bytes) {
+    const mb = bytes / (1024 * 1024);
+    const gb = mb / 1024;
+    if (gb >= 1) {
+        return `${gb.toFixed(2)} GB`;
+    }
+    if (mb >= 1) {
+        return `${mb.toFixed(2)} MB`;
+    }
+    if (bytes >= 1024) {
+        return `${(bytes / 1024).toFixed(2)} KB`;
+    }
+    return `${bytes} B`;
+}
 function formatSizeFromKb(sizeKb) {
     const sizeMb = sizeKb / 1024;
     if (sizeMb < 1024) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reposizer",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "description": "Fast CLI to inspect GitHub repository sizes",
   "license": "MIT",
   "author": "Hanif",
@@ -19,7 +19,9 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "dev": "tsx bin/reposizer.ts",
-    "check": "tsc --noEmit -p tsconfig.json"
+    "check": "tsc --noEmit -p tsconfig.json",
+    "video": "remotion studio remotion/index.js",
+    "video:render": "remotion render remotion/index.js ReposizerIntro out/reposizer-intro.mp4"
   },
   "keywords": [
     "cli",
@@ -29,7 +31,11 @@
     "typescript"
   ],
   "dependencies": {
-    "commander": "^12.1.0"
+    "@remotion/cli": "^4.0.452",
+    "commander": "^12.1.0",
+    "react": "^19.2.5",
+    "react-dom": "^19.2.5",
+    "remotion": "^4.0.452"
   },
   "devDependencies": {
     "@types/node": "^22.13.10",