reposizer 0.1.2 → 0.2.2

package/README.md

@@ -24,9 +24,10 @@ Language: C
 - 📦 Works with `npx` (no global install required)
 - 🧩 JSON output for scripts and CI tooling
 - 🏢 Organization repository scanning
-- 🔎 Current repository auto-detection (via git remote)
+- 🔎 Current repository auto-detection (via `.git/config`)
 - 📚 Multi-repository lookup in one command
-- 📊 Directory analysis (planned)
+- 📊 Directory analysis (no clone)
+- 🧮 Approximate LOC analysis (no clone)
 
 ## Installation
 
@@ -54,6 +55,7 @@ reposizer openai/gym
 
 ```bash
 reposizer openai/gym vercel/next.js torvalds/linux
+reposizer openai/gym vercel/next.js --sort stars
 ```
 
 ### Detect current repository automatically
@@ -69,6 +71,19 @@ reposizer org openai
 reposizer org openai --limit 50 --json
 ```
 
+### Analyze top directories (no clone)
+
+```bash
+reposizer vercel/next.js --analyze
+```
+
+### Estimate lines of code (no clone)
+
+```bash
+reposizer vercel/next.js --loc
+reposizer vercel/next.js --loc --json
+```
+
 ### JSON output
 
 ```bash
@@ -98,7 +113,8 @@ reposizer your-org/private-repo
 - [x] Organization scanning
 - [x] Current repository auto-detection
 - [x] Multi-repository support
-- [ ] Directory size analysis
+- [x] Directory size analysis
+- [x] Approximate LOC analysis
 - [ ] CI/CD threshold mode
 - [ ] Repository growth tracking
 

package/dist/bin/reposizer.js

@@ -10,9 +10,18 @@ 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("--loc", "Approximate lines of code using 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), Boolean(options.loc), sortRaw);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : "Unexpected error occurred";
@@ -20,7 +29,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 vercel/next.js --loc\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/loc.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocPayload = getLocPayload;
+exports.printLocResult = printLocResult;
+exports.runLocCommand = runLocCommand;
+const tree_1 = require("../services/tree");
+const IGNORED_SEGMENTS = new Set([
+    "node_modules",
+    "dist",
+    "build",
+    ".next",
+    "coverage",
+    ".git"
+]);
+const EXTENSION_TO_LANGUAGE = {
+    ts: "TypeScript",
+    tsx: "TypeScript",
+    js: "JavaScript",
+    jsx: "JavaScript",
+    mjs: "JavaScript",
+    cjs: "JavaScript",
+    py: "Python",
+    rb: "Ruby",
+    php: "PHP",
+    java: "Java",
+    kt: "Kotlin",
+    rs: "Rust",
+    go: "Go",
+    c: "C",
+    h: "C",
+    cc: "C++",
+    cpp: "C++",
+    cxx: "C++",
+    hpp: "C++",
+    cs: "C#",
+    swift: "Swift",
+    scala: "Scala",
+    r: "R",
+    sh: "Shell",
+    bash: "Shell",
+    zsh: "Shell",
+    ps1: "PowerShell",
+    sql: "SQL",
+    html: "HTML",
+    css: "CSS",
+    scss: "SCSS",
+    less: "Less",
+    vue: "Vue",
+    svelte: "Svelte",
+    json: "JSON",
+    yml: "YAML",
+    yaml: "YAML",
+    toml: "TOML",
+    md: "Markdown",
+    mdx: "Markdown",
+    txt: "Text"
+};
+const AVG_BYTES_PER_LINE = {
+    TypeScript: 33,
+    JavaScript: 34,
+    Python: 28,
+    Ruby: 30,
+    PHP: 32,
+    Java: 36,
+    Kotlin: 36,
+    Rust: 34,
+    Go: 31,
+    C: 30,
+    "C++": 33,
+    "C#": 35,
+    Swift: 35,
+    Scala: 37,
+    R: 29,
+    Shell: 27,
+    PowerShell: 32,
+    SQL: 36,
+    HTML: 40,
+    CSS: 34,
+    SCSS: 36,
+    Less: 35,
+    Vue: 38,
+    Svelte: 36,
+    JSON: 48,
+    YAML: 42,
+    TOML: 32,
+    Markdown: 52,
+    Text: 62,
+    Other: 38
+};
+function shouldIgnore(path) {
+    const segments = path.split("/");
+    return segments.some((segment) => IGNORED_SEGMENTS.has(segment));
+}
+function getLanguageFromPath(path) {
+    const fileName = path.split("/").pop() ?? path;
+    if (fileName.endsWith(".min.js") || fileName.endsWith(".min.css")) {
+        return "Other";
+    }
+    const ext = fileName.includes(".") ? fileName.split(".").pop() ?? "" : "";
+    if (!ext) {
+        return "Other";
+    }
+    return EXTENSION_TO_LANGUAGE[ext.toLowerCase()] ?? "Other";
+}
+function estimateLines(language, sizeBytes) {
+    const divisor = AVG_BYTES_PER_LINE[language] ?? AVG_BYTES_PER_LINE.Other;
+    return Math.max(1, Math.round(sizeBytes / divisor));
+}
+function toSortedEntries(record, limit) {
+    return Object.entries(record)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, limit)
+        .map(([key, value]) => ({ key, value }));
+}
+async function getLocPayload(owner, repo) {
+    const { tree, truncated } = await (0, tree_1.getRepoTree)(owner, repo);
+    const byLanguage = {};
+    const byDirectory = {};
+    let totalLines = 0;
+    for (const item of tree) {
+        if (item.type !== "blob") {
+            continue;
+        }
+        const path = item.path;
+        if (shouldIgnore(path)) {
+            continue;
+        }
+        const sizeBytes = item.size ?? 0;
+        if (sizeBytes === 0) {
+            continue;
+        }
+        const language = getLanguageFromPath(path);
+        const lines = estimateLines(language, sizeBytes);
+        totalLines += lines;
+        byLanguage[language] = (byLanguage[language] ?? 0) + lines;
+        const topDir = path.includes("/") ? path.split("/")[0] : "root";
+        byDirectory[topDir] = (byDirectory[topDir] ?? 0) + lines;
+    }
+    const topLanguages = toSortedEntries(byLanguage, 10).map(({ key, value }) => ({
+        language: key,
+        lines: value
+    }));
+    const topDirectories = toSortedEntries(byDirectory, 10).map(({ key, value }) => ({
+        directory: key,
+        lines: value
+    }));
+    return {
+        repository: `${owner}/${repo}`,
+        approx: true,
+        truncated,
+        total_lines: totalLines,
+        by_language: topLanguages,
+        by_directory: topDirectories,
+        method: "size-based-estimate"
+    };
+}
+function printLocResult(payload) {
+    const formatLineCount = (value) => new Intl.NumberFormat("en-US").format(value);
+    if (payload.truncated) {
+        console.error("Warning: Git tree response was truncated by GitHub; LOC totals may be incomplete.");
+    }
+    console.log(`Repository: ${payload.repository}`);
+    console.log(`Total LOC (approx): ${formatLineCount(payload.total_lines)}`);
+    console.log("");
+    console.log("Top languages:");
+    console.log("--------------");
+    for (const row of payload.by_language) {
+        console.log(`${row.language.padEnd(15)} ${formatLineCount(row.lines)}`);
+    }
+    console.log("");
+    console.log("Top directories:");
+    console.log("----------------");
+    for (const row of payload.by_directory) {
+        console.log(`${row.directory.padEnd(15)} ${formatLineCount(row.lines)}`);
+    }
+}
+async function runLocCommand(owner, repo) {
+    const payload = await getLocPayload(owner, repo);
+    printLocResult(payload);
+}

package/dist/src/commands/repo.js

@@ -4,18 +4,78 @@ exports.runRepoCommand = runRepoCommand;
 exports.runRepositoriesCommand = runRepositoriesCommand;
 exports.runOrganizationCommand = runOrganizationCommand;
 const github_1 = require("../services/github");
+const analyze_1 = require("./analyze");
+const loc_1 = require("./loc");
 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;
+const LOC_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 = {
@@ -29,6 +89,8 @@ async function runRepoCommand(repositoryInput, jsonOutput) {
     }
     console.log(`Repository: ${metadata.fullName}`);
     console.log(`Size: ${(0, size_1.formatSizeFromKb)(metadata.sizeKb)}`);
+    const loc = await (0, loc_1.getLocPayload)(owner, repo);
+    console.log(`Lines: ${(0, size_1.formatCompactCount)(loc.total_lines)}`);
     console.log(`Stars: ${(0, size_1.formatStars)(metadata.stargazersCount)}`);
     console.log(`Language: ${metadata.language ?? "Unknown"}`);
 }
@@ -66,26 +128,77 @@ function buildPayload(repositoryInput, metadata) {
         language: metadata.language ?? "Unknown"
     };
 }
-async function runRepositoriesCommand(repositoryInputs, jsonOutput) {
+async function runRepositoriesCommand(repositoryInputs, jsonOutput, analyze = false, loc = false, sort = "size") {
+    if (analyze && loc) {
+        throw new Error('Use either "--analyze" or "--loc", not both together.');
+    }
     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;
+    }
+    if (loc) {
+        if (jsonOutput) {
+            const payloads = await mapWithConcurrency(parsedArgs, LOC_FETCH_CONCURRENCY, async (item) => (0, loc_1.getLocPayload)(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, loc_1.runLocCommand)(only.owner, only.repo);
+            return;
+        }
+        const payloads = await mapWithConcurrency(parsedArgs, LOC_FETCH_CONCURRENCY, async (item) => (0, loc_1.getLocPayload)(item.owner, item.repo));
+        for (let i = 0; i < payloads.length; i++) {
+            (0, loc_1.printLocResult)(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];
+        const only = parsedArgs[0];
+        const loc = await (0, loc_1.getLocPayload)(only.owner, only.repo);
         console.log(`Repository: ${result.repository}`);
         console.log(`Size: ${(0, size_1.formatSizeFromKb)(result.size_mb * 1024)}`);
+        console.log(`Lines: ${(0, size_1.formatCompactCount)(loc.total_lines)} `);
         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 +217,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,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatBytes = formatBytes;
 exports.formatSizeFromKb = formatSizeFromKb;
 exports.kbToMbRounded = kbToMbRounded;
 exports.formatStars = formatStars;
+exports.formatCompactCount = formatCompactCount;
+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) {
@@ -20,3 +36,15 @@ function formatStars(value) {
     }
     return String(value);
 }
+function formatCompactCount(value) {
+    if (value >= 1_000_000_000) {
+        return `${(value / 1_000_000_000).toFixed(1)}B`;
+    }
+    if (value >= 1_000_000) {
+        return `${(value / 1_000_000).toFixed(1)}M`;
+    }
+    if (value >= 1_000) {
+        return `${(value / 1_000).toFixed(1)}K`;
+    }
+    return String(value);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reposizer",
-  "version": "0.1.2",
+  "version": "0.2.2",
   "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",