npm - @vladimirshefer/git-stats - Versions diffs - 0.0.1 → 0.0.2 - Mend

@vladimirshefer/git-stats 0.0.1 → 0.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist/index.js +694 -364
package/package.json +1 -1

package/dist/index.js CHANGED Viewed

@@ -6,10 +6,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -26,64 +22,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 // src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  distinctCount: () => distinctCount
-});
-module.exports = __toCommonJS(index_exports);
-var import_child_process2 = require("child_process");
-// src/util/exec.ts
-var import_child_process = require("child_process");
-function execAsync(command, args = [], options = {}) {
-  return new Promise((resolve2, reject) => {
-    const child = (0, import_child_process.spawn)(command, args, { ...options, shell: true });
-    let stdout = [];
-    let stderr = [];
-    let stdoutBuffer = "";
-    let stderrBuffer = "";
-    child.stdout.on("data", (data) => {
-      stdoutBuffer += data.toString();
-      const lines = stdoutBuffer.split("\n");
-      for (let i = 0; i < lines.length - 1; i++) {
-        stdout.push(lines[i]);
-      }
-      stdoutBuffer = lines[lines.length - 1];
-    });
-    child.stderr.on("data", (data) => {
-      stderrBuffer += data.toString();
-      const lines = stderrBuffer.split("\n");
-      for (let i = 0; i < lines.length - 1; i++) {
-        stderr.push(lines[i]);
-      }
-      stderrBuffer = lines[lines.length - 1];
-    });
-    child.on("error", (err) => {
-      reject(err);
-    });
-    child.on("close", (code) => {
-      if (stdoutBuffer.length > 0) {
-        stdout.push(stdoutBuffer);
-      }
-      if (stderrBuffer.length > 0) {
-        stderr.push(stderrBuffer);
-      }
-      if (code === 0) {
-        resolve2({ stdout, stderr });
-      } else {
-        reject(new Error(`Command failed with code ${code}
-${stderr.join("\n")}`));
-      }
-    });
-  });
-}
-// src/index.ts
-var fs4 = __toESM(require("fs"));
-var path4 = __toESM(require("path"));
+var fs3 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
 // src/output/report_template.ts
 var path = __toESM(require("path"));
@@ -100,25 +42,46 @@ var report_template_default = `<!DOCTYPE html>
     <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
     <script src="https://cdn.plot.ly/plotly-3.3.0.min.js" charset="utf-8"></script>
     <script src="https://cdn.jsdelivr.net/npm/@tailwindcss/browser@4"></script>
-    <!-- React 18 UMD builds -->
-    <script crossorigin src="https://unpkg.com/react@18/umd/react.production.min.js"></script>
-    <script crossorigin src="https://unpkg.com/react-dom@18/umd/react-dom.production.min.js"></script>
+    <!-- Preact UMD build -->
+    <script crossorigin src="https://unpkg.com/preact@10/dist/preact.umd.js"></script>
+    <script crossorigin src="https://unpkg.com/preact@10/hooks/dist/hooks.umd.js"></script>
     <!-- Babel Standalone for in-browser JSX transform -->
     <script src="https://unpkg.com/@babel/standalone/babel.min.js"></script>
 </head>
 <body class="font-sans m-0 bg-gray-50 text-gray-900">
 <div id="root"></div>
+</body>
 <script type="text/babel" data-presets="react">
+    // Preact compat aliases
+    const React = window.preact;
+    const ReactDOM = {
+        createRoot: (container) => ({
+            render: (element) => window.preact.render(element, container)
+        })
+    };
+    React.useRef = window.preactHooks.useRef;
+    React.useEffect = window.preactHooks.useEffect;
+    React.useState = window.preactHooks.useState;
+    React.useMemo = window.preactHooks.useMemo;
     const RAW_DATASET =
         __DATASET_JSON__
-        || [];
+        || [[1,2,3,4,5,6,7,8,9]];
     // Fixed schema as per pipeline: [author, days_bucket, lang, clusterPath, repoName, count]
-    const HEADER_LABELS = ["author", "days_bucket", "lang", "clusterPath", "repoName", "count"];
+    const RAW_DATASET_SCHEMA = ["author", "days_bucket", "lang", "clusterPath", "repoName", "count"];
+    const CLUSTER_COLUMN = RAW_DATASET_SCHEMA.indexOf("clusterPath");
+    const REPO_COLUMN = RAW_DATASET_SCHEMA.indexOf("repoName");
     // -------- Client-side grouping/filtering engine --------
-    const KEY_INDEX = Object.fromEntries(HEADER_LABELS.map((k, i) => [k, i]));
+    const KEY_INDEX = Object.fromEntries(RAW_DATASET_SCHEMA.map((k, i) => [k, i]));
+    const COLUMNS_AMOUNT = RAW_DATASET[0].length - 1;
+    const COLUMNS_IDX_ARRAY = Array(COLUMNS_AMOUNT).fill(-1).map((_, i) => i);
     const COUNT_IDX_FROM_END = 1; // last element is count
+    const COLUMN_COMPARATORS = COLUMNS_IDX_ARRAY.map(idx => {
+        let isNumber = typeof RAW_DATASET?.[0]?.[idx] === "number";
+        return isNumber ? ((a, b) => (a || 0) - (b || 0)) : (a, b) => String(a).localeCompare(String(b));
+    })
+    const UNIQUE_VALUES = COLUMNS_IDX_ARRAY.map((idx) => uniqueValues(RAW_DATASET, idx).sort(COLUMN_COMPARATORS[idx]))
-    const allKeys = HEADER_LABELS.filter(k => k !== 'count');
     const TOP_N = 20;
     const BUCKET_COLORS = [
         'rgba(214, 40, 40, 0.7)',
@@ -136,110 +99,356 @@ var report_template_default = `<!DOCTYPE html>
         return Array.from(set);
     }
+    function matchesFilters(row, filters) {
+        for (let idx = 0; idx < COLUMNS_AMOUNT; idx++) {
+            const sel = filters[idx];
+            if (sel && !sel.has(String(row[idx]))) {
+                return false;
+            }
+        }
+        return true;
+    }
     function pivot(
         dataset,
-        primaryKeyIndex,
-        secondaryKeyIndex,
-        filterState
+        column1,
+        column2
     ) {
-        const pivot = new Map();
-        const totals = new Map();
+        const grouped2 = new Map();
         const secValuesSet = new Set();
         for (const row of dataset) {
-            let ok = true;
-            for (const key of allKeys) {
-                const idx = KEY_INDEX[key];
-                const sel = filterState[key];
-                if (sel && !sel.has(String(row[idx]))) {
-                    ok = false;
-                    break;
-                }
-            }
-            if (!ok) continue;
-            const pk = row[primaryKeyIndex];
-            const sk = row[secondaryKeyIndex];
+            const c1 = row[column1];
+            const c2 = row[column2];
             const count = Number(row[row.length - COUNT_IDX_FROM_END]) || 0;
-            if (!pivot.has(pk)) pivot.set(pk, new Map());
-            pivot.get(pk).set(sk, (pivot.get(pk).get(sk) || 0) + count);
-            totals.set(pk, (totals.get(pk) || 0) + count);
-            secValuesSet.add(sk);
+            if (!grouped2.has(c1)) grouped2.set(c1, new Map());
+            grouped2.get(c1).set(c2, (grouped2.get(c1).get(c2) || 0) + count);
+            secValuesSet.add(c2);
         }
-        const primaryKeys = Array.from(pivot.keys()).sort((a, b) => (totals.get(b) || 0) - (totals.get(a) || 0));
+        const primaryTotals = new Map();
+        for (const [c1, innerMap] of grouped2) {
+            let total = 0;
+            for (const val of innerMap.values()) total += val;
+            primaryTotals.set(c1, total);
+        }
+        const primaryKeys = Array.from(grouped2.keys()).sort((a, b) => (primaryTotals.get(b) || 0) - (primaryTotals.get(a) || 0));
         const secondaryKeys = Array.from(secValuesSet).sort((a, b) => String(a).localeCompare(String(b)));
-        return {pivot, totals, primaryKeys, secondaryKeys};
+        return {grouped2, primaryKeys, secondaryKeys};
+    }
+    function computeColumnTotals(dataset, columnIdx) {
+        const value2total = new Map();
+        const otherColumnContributions = new Map(); // Map<key, Map<otherColumnIdx, Map<otherValue, count>>>
+        for (const row of dataset) {
+            const value = row[columnIdx];
+            const count = Number(row[row.length - 1]) || 0;
+            value2total.set(value, (value2total.get(value) || 0) + count);
+            // Track contributions from other columns
+            if (!otherColumnContributions.has(value)) {
+                otherColumnContributions.set(value, new Map());
+            }
+            const keyContribs = otherColumnContributions.get(value);
+            for (let otherIdx = 0; otherIdx < COLUMNS_AMOUNT; otherIdx++) {
+                if (otherIdx === columnIdx) continue;
+                if (!keyContribs.has(otherIdx)) {
+                    keyContribs.set(otherIdx, new Map());
+                }
+                const otherColMap = keyContribs.get(otherIdx);
+                const otherValue = row[otherIdx];
+                otherColMap.set(otherValue, (otherColMap.get(otherValue) || 0) + count);
+            }
+        }
+        const sorted = Array.from(value2total.entries()).sort((a, b) => b[1] - a[1]);
+        return {
+            keys: sorted.map(([k]) => k),
+            values: sorted.map(([, v]) => v),
+            totals: value2total,
+            contributions: otherColumnContributions
+        };
     }
     // ---------- React Components ----------
-    function ChartView({labels, datasets}) {
-        const canvasRef = React.useRef(null);
-        const chartRef = React.useRef(null);
-        React.useEffect(() => {
-            const ctx = canvasRef.current.getContext('2d');
-            chartRef.current = new Chart(ctx, {
-                type: 'bar',
-                data: {labels: [], datasets: []},
-                options: {
-                    indexAxis: 'y',
-                    scales: {
-                        x: {stacked: true, beginAtZero: true},
-                        y: {stacked: true, ticks: {autoSkip: false}}
-                    },
-                    plugins: {
-                        tooltip: {
-                            callbacks: {
-                                label: function (context) {
-                                    let label = context.dataset.label || '';
-                                    if (label) label += ': ';
-                                    if (context.parsed.x !== null) label += context.parsed.x.toLocaleString();
-                                    return label;
-                                }
-                            }
+    function ColumnTotalCard({columnName, columnIdx, keys, values, totals, contributions}) {
+        const containerRef = React.useRef(null);
+        const {labels, hoverText} = React.useMemo(() => {
+            const labels = [];
+            const hoverText = [];
+            keys.forEach((k) => {
+                const total = totals.get(k);
+                const keyContribs = contributions.get(k);
+                const topContribs = [];
+                for (let otherIdx = 0; otherIdx < COLUMNS_AMOUNT; otherIdx++) {
+                    if (otherIdx === columnIdx) continue;
+                    const otherColMap = keyContribs?.get(otherIdx);
+                    if (otherColMap) {
+                        const top3 = Array.from(otherColMap.entries())
+                            .sort((a, b) => b[1] - a[1])
+                            .slice(0, 3)
+                            .map(([val, cnt]) => \`\${val}(\${(cnt / total * 100.0).toFixed(1)}%)\`)
+                            .join('<br>-');
+                        if (top3) {
+                            topContribs.push(\`\${RAW_DATASET_SCHEMA[otherIdx]}<br>-\` + top3);
                         }
                     }
                 }
+                const label = \`\${String(k)} (\${total})\`;
+                labels.push(label);
+                hoverText.push(topContribs.length > 0 ? \`\${label}<br>\${topContribs.join('<br>')}\` : label);
             });
-            return () => {
-                chartRef.current && chartRef.current.destroy();
+            return {labels, hoverText};
+        }, [columnName, columnIdx, keys, totals, contributions]);
+        React.useEffect(() => {
+            const el = containerRef.current;
+            if (!el) return;
+            if (!labels.length) {
+                el.innerHTML = '<div class="text-gray-500 py-6 text-center">No data to display</div>';
+                return;
+            }
+            const trace = {
+                type: 'sunburst',
+                labels: labels,
+                parents: labels.map(() => ''),
+                values: values,
+                hovertext: hoverText,
+                hovertemplate: '%{hovertext}<extra></extra>',
+                branchvalues: 'total'
             };
-        }, []);
+            const layout = {
+                margin: {l: 0, r: 0, t: 10, b: 10},
+                sunburstcolorway: ['#4F46E5', '#10B981', '#F59E0B', '#EF4444', '#06B6D4', '#8B5CF6', '#F43F5E'],
+                extendsunburstcolors: true,
+                height: 300
+            };
+            const config = {responsive: true, displayModeBar: false};
+            if (window.Plotly && window.Plotly.newPlot) {
+                window.Plotly.newPlot(el, [trace], layout, config);
+            }
+        }, [labels, hoverText, values]);
+        return (
+            <div className="bg-white border border-gray-200 rounded-lg p-4 shadow-sm">
+                <h3 className="text-lg font-semibold mb-3 text-gray-800">{columnName} - Total</h3>
+                <div ref={containerRef} className="w-full"/>
+            </div>
+        );
+    }
+    // ---------- Sunburst over repository paths (clusterPath) ----------
+    function buildSunburst(dataset, filterState) {
+        const filtered = dataset.filter(row => matchesFilters(row, filterState));
+        const PSEUDO_ROOT = "@";
+        // Aggregate counts per path and propagate sums up the tree
+        const leafSums = new Map(); // fullPath -> sum
+        const allPaths = new Set(); // includes all prefixes (no empty)
+        for (const row of filtered) {
+            const rawPath = String(row[REPO_COLUMN] + "/" + row[CLUSTER_COLUMN] ?? '').trim();
+            const cnt = Number(row[COLUMNS_AMOUNT]) || 0;
+            if (!rawPath) continue;
+            const segs = rawPath.split('/').filter(s => s && s !== '.');
+            if (segs.length === 0) continue;
+            const full = segs.join('/');
+            leafSums.set(full, (leafSums.get(full) || 0) + cnt);
+            // Collect all prefix nodes for structure
+            for (let i = 0; i < segs.length; i++) {
+                const p = segs.slice(0, i + 1).join('/');
+                allPaths.add(p);
+            }
+        }
+        if (allPaths.size === 0) return {ids: [], labels: [], parents: [], values: []};
+        // Compute total values for every node as sum of its descendant leaves
+        const totals = new Map(Array.from(allPaths, p => [p, 0]));
+        for (const [leaf, v] of leafSums) {
+            const segs = leaf.split('/');
+            for (let i = 0; i < segs.length; i++) {
+                const p = segs.slice(0, i + 1).join('/');
+                totals.set(p, (totals.get(p) || 0) + v);
+            }
+        }
+        // Build Plotly arrays
+        const ids = [];
+        const labels = [];
+        const parents = [];
+        const values = [];
+        // Ensure stable ordering: sort by path length then alphabetically
+        const ordered = Array.from(allPaths);
+        ordered.sort((a, b) => {
+            const da = a.split('/').length, db = b.split('/').length;
+            if (da !== db) return da - db;
+            return a.localeCompare(b);
+        });
+        for (const id of ordered) {
+            const segs = id.split('/');
+            const label = segs[segs.length - 1] || id;
+            const parent = segs.length > 1 ? segs.slice(0, -1).join('/') : '';
+            ids.push(id);
+            labels.push(label);
+            parents.push(parent);
+            values.push(totals.get(id) || 0);
+        }
+        return {ids, labels, parents, values};
+    }
+    function SunburstPaths({dataset, filters}) {
+        const containerRef = React.useRef(null);
+        const data = React.useMemo(() => buildSunburst(dataset, filters), [dataset, filters]);
         React.useEffect(() => {
-            if (!chartRef.current) return;
-            chartRef.current.data.labels = labels;
-            chartRef.current.data.datasets = datasets;
-            chartRef.current.update();
-        }, [labels, datasets]);
+            const el = containerRef.current;
+            if (!el) return;
+            if (!data.ids.length) {
+                el.innerHTML = '<div class="text-gray-500 py-6 text-center">No path data to display</div>';
+                return;
+            }
+            const trace = {
+                type: 'sunburst',
+                ids: data.ids,
+                labels: data.labels,
+                parents: data.parents,
+                values: data.values,
+                branchvalues: 'total',
+                maxdepth: 3
+            };
+            const layout = {
+                margin: {l: 0, r: 0, t: 10, b: 10},
+                sunburstcolorway: ['#4F46E5', '#10B981', '#F59E0B', '#EF4444', '#06B6D4', '#8B5CF6', '#F43F5E'],
+                extendsunburstcolors: true,
+                height: 400
+            };
+            const config = {responsive: true, displayModeBar: false};
+            // Use Plotly from global
+            if (window.Plotly && window.Plotly.newPlot) {
+                window.Plotly.newPlot(el, [trace], layout, config);
+            }
+        }, [data]);
-        return <canvas ref={canvasRef}/>;
+        return <div ref={containerRef} className="w-full"/>;
     }
     function MultiSelect({label, values, selectedSet, onChange}) {
+        const [isOpen, setIsOpen] = React.useState(false);
+        const [searchTerm, setSearchTerm] = React.useState('');
+        const dropdownRef = React.useRef(null);
+        React.useEffect(() => {
+            function handleClickOutside(event) {
+                if (dropdownRef.current && !dropdownRef.current.contains(event.target)) {
+                    setIsOpen(false);
+                }
+            }
+            document.addEventListener('mousedown', handleClickOutside);
+            return () => document.removeEventListener('mousedown', handleClickOutside);
+        }, []);
+        const filteredValues = React.useMemo(() => {
+            if (!searchTerm) return values;
+            const lower = searchTerm.toLowerCase();
+            return values.filter(v => String(v).toLowerCase().includes(lower));
+        }, [values, searchTerm]);
         const selCount = selectedSet.size;
         const total = values.length;
+        const toggleValue = (val) => {
+            const newSet = new Set(selectedSet);
+            if (newSet.has(val)) {
+                newSet.delete(val);
+            } else {
+                newSet.add(val);
+            }
+            onChange(newSet);
+        };
         return (
-            <div>
+            <div ref={dropdownRef} className="relative">
                 <label className="block font-semibold mb-1.5">
                     {label}{' '}
                     <span className="text-gray-600 font-normal">({selCount}/{total})</span>
                 </label>
-                <select
-                    multiple
-                    size={Math.min(8, Math.max(3, values.length))}
-                    className="w-full"
-                    onChange={(e) => {
-                        const chosen = Array.from(e.target.selectedOptions).map(o => o.value);
-                        onChange(new Set(chosen));
-                    }}
+                <button
+                    type="button"
+                    onClick={() => setIsOpen(!isOpen)}
+                    className="w-full px-3 py-2 text-left bg-white border border-gray-300 rounded-md shadow-sm hover:bg-gray-50 focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500"
                 >
-                    {values.map(v => {
-                        const strVal = String(v);
-                        return (
-                            <option key={strVal} value={strVal} selected={selectedSet.has(strVal)}>
-                                {strVal}
-                            </option>
-                        );
-                    })}
-                </select>
+                    <span className="text-gray-700">
+                        {selCount === 0 ? 'Select...' : selCount === total ? 'All selected' : \`\${selCount} selected\`}
+                    </span>
+                    <span className="float-right">\u25BC</span>
+                </button>
+                {isOpen && (
+                    <div
+                        className="absolute z-10 w-full mt-1 bg-white border border-gray-300 rounded-md shadow-lg max-h-80 overflow-hidden">
+                        <div className="p-2 border-b border-gray-200">
+                            <input
+                                type="text"
+                                placeholder="Search..."
+                                value={searchTerm}
+                                onChange={(e) => setSearchTerm(e.target.value)}
+                                className="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500"
+                                onClick={(e) => e.stopPropagation()}
+                            />
+                            <div className="flex gap-2 mt-2">
+                                <button
+                                    type="button"
+                                    onClick={() => onChange(new Set(values.map(String)))}
+                                    className="flex-1 px-3 py-1.5 text-sm bg-blue-600 text-white rounded-md hover:bg-blue-700 focus:outline-none focus:ring-2 focus:ring-blue-500"
+                                >
+                                    Select All
+                                </button>
+                                <button
+                                    type="button"
+                                    onClick={() => onChange(new Set())}
+                                    className="flex-1 px-3 py-1.5 text-sm bg-gray-600 text-white rounded-md hover:bg-gray-700 focus:outline-none focus:ring-2 focus:ring-gray-500"
+                                >
+                                    Unselect All
+                                </button>
+                            </div>
+                        </div>
+                        <div className="overflow-y-auto max-h-64">
+                            {filteredValues.length === 0 ? (
+                                <div className="px-3 py-2 text-gray-500 text-center">No matches found</div>
+                            ) : (
+                                filteredValues.map(v => {
+                                    const val = String(v);
+                                    const isChecked = selectedSet.has(val);
+                                    return (
+                                        <label
+                                            key={val}
+                                            className="flex items-center px-3 py-2 hover:bg-gray-100 cursor-pointer"
+                                        >
+                                            <input
+                                                type="checkbox"
+                                                checked={isChecked}
+                                                onChange={() => toggleValue(val)}
+                                                className="mr-2 h-4 w-4 text-blue-600 border-gray-300 rounded focus:ring-blue-500"
+                                            />
+                                            <span className="text-gray-900">{val}</span>
+                                        </label>
+                                    );
+                                })
+                            )}
+                        </div>
+                    </div>
+                )}
             </div>
         );
     }
@@ -248,14 +457,9 @@ var report_template_default = `<!DOCTYPE html>
         const {initialFilters, valueOptions} = React.useMemo(() => {
             const filters = {};
             const options = {};
-            for (const key of allKeys) {
-                const idx = KEY_INDEX[key];
-                const values = uniqueValues(RAW_DATASET, idx).sort((a, b) => {
-                    if (key === 'days_bucket') return Number(a) - Number(b);
-                    return String(a).localeCompare(String(b));
-                });
-                filters[key] = new Set(values.map(v => String(v)));
-                options[key] = values;
+            for (let idx = 0; idx < COLUMNS_AMOUNT; idx++) {
+                filters[idx] = new Set(UNIQUE_VALUES[idx].map(v => String(v)));
+                options[idx] = UNIQUE_VALUES[idx];
             }
             return {initialFilters: filters, valueOptions: options};
         }, []);
@@ -264,11 +468,12 @@ var report_template_default = `<!DOCTYPE html>
         const [secondaryKeyIndex, setSecondaryKeyIndex] = React.useState(1);
         const {chartLabels, datasets} = React.useMemo(() => {
+            const filteredDataset = RAW_DATASET.filter(row => matchesFilters(row, filters));
             const {
-                pivot: pv,
+                grouped2: pv,
                 primaryKeys,
                 secondaryKeys
-            } = pivot(RAW_DATASET, primaryKeyIndex, secondaryKeyIndex, filters);
+            } = pivot(filteredDataset, primaryKeyIndex, secondaryKeyIndex);
             const chartPrimaryKeys = primaryKeys.slice(0, TOP_N);
             const ds = secondaryKeys.map((sk, i) => ({
                 label: String(sk),
@@ -287,8 +492,8 @@ var report_template_default = `<!DOCTYPE html>
                         <label>
                             Primary group:
                             <select value={primaryKeyIndex} onChange={e => setPrimaryKeyIndex(Number(e.target.value))}>
-                                {allKeys.map((__, i) => (
-                                    <option key={i} value={i}>{HEADER_LABELS[i]}</option>
+                                {COLUMNS_IDX_ARRAY.map((__, i) => (
+                                    <option key={i} value={i}>{RAW_DATASET_SCHEMA[i]}</option>
                                 ))}
                             </select>
                         </label>
@@ -296,27 +501,48 @@ var report_template_default = `<!DOCTYPE html>
                             Secondary group:
                             <select value={secondaryKeyIndex}
                                     onChange={e => setSecondaryKeyIndex(Number(e.target.value))}>
-                                {allKeys.map((__, i) => (
-                                    <option key={i} value={i}>{HEADER_LABELS[i]}</option>
+                                {COLUMNS_IDX_ARRAY.map((__, i) => (
+                                    <option key={i} value={i}>{RAW_DATASET_SCHEMA[i]}</option>
                                 ))}
                             </select>
                         </label>
                     </div>
                     <div id="filters" className="mt-3 grid grid-cols-[repeat(auto-fit,minmax(220px,1fr))] gap-3">
-                        {allKeys.map((key, idx) => (
+                        {COLUMNS_IDX_ARRAY.map((__, idx) => (
                             <MultiSelect
                                 key={idx}
-                                label={HEADER_LABELS[idx]}
-                                values={valueOptions[key]}
-                                selectedSet={filters[key]}
-                                onChange={(newSet) => setFilters(prev => ({...prev, [key]: newSet}))}
+                                label={RAW_DATASET_SCHEMA[idx]}
+                                values={valueOptions[idx]}
+                                selectedSet={filters[idx]}
+                                onChange={(newSet) => setFilters(prev => ({...prev, [idx]: newSet}))}
                             />
                         ))}
                     </div>
                 </div>
-                <div className="mt-5">
-                    <h2 id="chartTitle" className="border-b border-gray-300 pb-2.5">Chart</h2>
-                    <ChartView labels={chartLabels} datasets={datasets}/>
+                <div className="mt-8">
+                    <h2 className="border-b border-gray-300 pb-2.5">Column Totals</h2>
+                    <div className="grid grid-cols-1 md:grid-cols-2 gap-4 mt-4">
+                        {COLUMNS_IDX_ARRAY.map((__, idx) => {
+                            const filteredDataset = RAW_DATASET.filter(row => matchesFilters(row, filters));
+                            const {keys, values, totals, contributions} = computeColumnTotals(filteredDataset, idx);
+                            return (
+                                <ColumnTotalCard
+                                    key={idx}
+                                    columnName={RAW_DATASET_SCHEMA[idx]}
+                                    columnIdx={idx}
+                                    keys={keys}
+                                    values={values}
+                                    totals={totals}
+                                    contributions={contributions}
+                                />
+                            );
+                        })}
+                    </div>
+                </div>
+                <div className="mt-8">
+                <h2 className="border-b border-gray-300 pb-2.5">Repository Paths Sunburst</h2>
+                    <p className="text-sm text-gray-600 mt-2 mb-3">Breakdown by folder structure based on <code>clusterPath</code> within current filters.</p>
+                    <SunburstPaths dataset={RAW_DATASET} filters={filters}/>
                 </div>
             </div>
         );
@@ -325,7 +551,6 @@ var report_template_default = `<!DOCTYPE html>
     const root = ReactDOM.createRoot(document.getElementById('root'));
     root.render(<App/>);
 </script>
-</body>
 </html>
 `;
@@ -345,6 +570,53 @@ function generateHtmlReport(data, outputFile) {
 // src/git.ts
 var import_path = __toESM(require("path"));
 var import_fs = __toESM(require("fs"));
+// src/util/exec.ts
+var import_child_process = require("child_process");
+function execAsync(command, args = [], options = {}) {
+  return new Promise((resolve2, reject) => {
+    const child = (0, import_child_process.spawn)(command, args, { ...options });
+    let stdout = [];
+    let stderr = [];
+    let stdoutBuffer = "";
+    let stderrBuffer = "";
+    child.stdout.on("data", (data) => {
+      stdoutBuffer += data.toString();
+      const lines = stdoutBuffer.split("\n");
+      for (let i = 0; i < lines.length - 1; i++) {
+        stdout.push(lines[i]);
+      }
+      stdoutBuffer = lines[lines.length - 1];
+    });
+    child.stderr.on("data", (data) => {
+      stderrBuffer += data.toString();
+      const lines = stderrBuffer.split("\n");
+      for (let i = 0; i < lines.length - 1; i++) {
+        stderr.push(lines[i]);
+      }
+      stderrBuffer = lines[lines.length - 1];
+    });
+    child.on("error", (err) => {
+      reject(err);
+    });
+    child.on("close", (code) => {
+      if (stdoutBuffer.length > 0) {
+        stdout.push(stdoutBuffer);
+      }
+      if (stderrBuffer.length > 0) {
+        stderr.push(stderrBuffer);
+      }
+      if (code === 0) {
+        resolve2({ stdout, stderr });
+      } else {
+        reject(new Error(`Command ${command} ${JSON.stringify(args)} failed with code ${code}
+${stderr.join("\n")}`));
+      }
+    });
+  });
+}
+// src/git.ts
 async function executeGitBlamePorcelain(file, repoRoot, revisionBoundary, since) {
   const args = ["blame", "--line-porcelain"];
   if (since) {
@@ -425,37 +697,14 @@ async function findRevision(repoRoot, commitsBack) {
   }
   return void 0;
 }
-// src/vfs.ts
-var import_fs2 = __toESM(require("fs"));
-var import_path2 = __toESM(require("path"));
-var RealFileSystemImpl = class {
-  constructor(basePath) {
-    this.basePath = import_path2.default.normalize(basePath);
-  }
-  async read(filePath) {
-    return import_fs2.default.readFileSync(this.resolve(filePath), "utf8");
-  }
-  async write(filePath, content) {
-    let path1 = import_path2.default.resolve(this.resolve(filePath), "..");
-    import_fs2.default.mkdirSync(path1, { recursive: true });
-    import_fs2.default.writeFileSync(this.resolve(filePath), content);
-  }
-  async append(filePath, content) {
-    return new Promise((resolve2, reject) => {
-      import_fs2.default.appendFile(this.resolve(filePath), content, (err) => {
-        if (!err) {
-          resolve2(void 0);
-        } else {
-          reject(err);
-        }
-      });
-    });
-  }
-  resolve(filePath) {
-    return import_path2.default.normalize(`${this.basePath}/${filePath}`);
-  }
-};
+async function git_ls_files(repoRootPath, subdirPath) {
+  const { stdout: lsFilesOut } = await execAsync(
+    "git",
+    ["ls-files", "--", subdirPath || "."],
+    { cwd: repoRootPath }
+  );
+  return lsFilesOut.filter((line) => line && line.length > 0);
+}
 // src/util/AsyncGeneratorUtil.ts
 var AsyncGeneratorUtil = class {
@@ -503,7 +752,7 @@ var AsyncGeneratorUtil = class {
     });
   }
 };
-var AsyncIteratorWrapperImpl = class _AsyncIteratorWrapperImpl {
+var AsyncIteratorWrapperImpl = class {
   constructor(source) {
     this.source = source;
   }
@@ -511,14 +760,14 @@ var AsyncIteratorWrapperImpl = class _AsyncIteratorWrapperImpl {
     return this.source;
   }
   map(mapper) {
-    return new _AsyncIteratorWrapperImpl(async function* (source, mapper2) {
+    return streamOf(async function* (source, mapper2) {
       for await (const item of source) {
         yield mapper2(item);
       }
     }(this.source, mapper));
   }
   flatMap(mapper) {
-    return new _AsyncIteratorWrapperImpl(AsyncGeneratorUtil.flatMap(this.source, mapper));
+    return streamOf(AsyncGeneratorUtil.flatMap(this.source, mapper));
   }
   async forEach(consumer) {
     for await (const item of this.source) {
@@ -526,137 +775,197 @@ var AsyncIteratorWrapperImpl = class _AsyncIteratorWrapperImpl {
     }
   }
 };
-// src/util/file_tree_clustering.ts
-function clusterFiles(files, clusterMaxSize, clusterMinSize) {
-  let fileInfos = files.map((it) => {
-    let arr = it.split("/");
-    return { arr, str: it };
-  });
-  let initialCluster = { path: [], files: fileInfos, isLeftovers: false, isUnclusterable: false };
-  let clusterGroups = [initialCluster];
-  let changes = true;
-  function mostFrequent(arr) {
-    const counts = {};
-    for (const item of arr) {
-      counts[item] = (counts[item] || 0) + 1;
-    }
-    let maxCount = 0;
-    let mostFrequentItem = arr[0];
-    for (const item in counts) {
-      if (counts[item] > maxCount) {
-        maxCount = counts[item];
-        mostFrequentItem = item;
+function streamOf(source) {
+  return new AsyncIteratorWrapperImpl(source);
+}
+var stream;
+((stream2) => {
+  function ofArrayPromise(p) {
+    async function* __ofArrayPromise(p2) {
+      const items = await p2;
+      for (const item of items) {
+        yield item;
       }
     }
-    return mostFrequentItem;
-  }
-  while (changes) {
-    changes = false;
-    clusterGroups = clusterGroups.flatMap((originalCluster) => {
-      if (originalCluster.files.length > clusterMaxSize && !originalCluster.isUnclusterable) {
-        let l = originalCluster.path.length;
-        let mf = mostFrequent(originalCluster.files.map((it) => it.arr[l] || "$$$notfound$$$"));
-        let newClusterFiles = [];
-        let remainingFiles = originalCluster.files.filter((it) => {
-          let nextPathSegment = it.arr[l];
-          if (nextPathSegment === mf) {
-            newClusterFiles.push(it);
-            return false;
-          } else {
-            return true;
-          }
-        });
-        changes = true;
-        if (remainingFiles.length === 0) {
-          return [
-            {
-              path: originalCluster.path.concat([mf]),
-              files: newClusterFiles,
-              isLeftovers: false
-            }
-          ];
+    return streamOf(__ofArrayPromise(p));
+  }
+  stream2.ofArrayPromise = ofArrayPromise;
+})(stream || (stream = {}));
+// src/util/file_tree_clustering.ts
+var graph;
+((graph2) => {
+  function buildGraph(files) {
+    const result = {
+      path: [],
+      children: {},
+      value: [],
+      size: 0
+    };
+    files.forEach((file) => {
+      let targetDir = result;
+      file.arr.slice(0, -1).forEach((pathSegment) => {
+        targetDir.size++;
+        if (!Object.prototype.hasOwnProperty.call(targetDir.children, pathSegment)) {
+          targetDir.children[pathSegment] = {
+            path: targetDir.path.concat([pathSegment]),
+            children: {},
+            value: [],
+            size: 0
+          };
         }
-        if (newClusterFiles.length < clusterMinSize || remainingFiles.length < clusterMinSize) {
-          return [{ ...originalCluster, isUnclusterable: true }];
+        targetDir = targetDir.children[pathSegment];
+      });
+      targetDir.value.push(file);
+    });
+    return result;
+  }
+  graph2.buildGraph = buildGraph;
+  function flatten(graphNode) {
+    if (Object.keys(graphNode.children).length === 0) {
+      return graphNode.value;
+    }
+    let fileInfos = Object.values(graphNode.children).flatMap((child) => flatten(child));
+    return fileInfos.concat(graphNode.value);
+  }
+  function bubbleMicroLeftovers(graphNode, clusterMaxSize, clusterMinSize) {
+    if (Object.keys(graphNode.children).length === 0) {
+      return false;
+    }
+    if (graphNode.size < clusterMaxSize) {
+      let allFiles = flatten(graphNode);
+      graphNode.children = {};
+      graphNode.value = allFiles;
+      graphNode.size = allFiles.length;
+      return true;
+    }
+    let result = false;
+    Object.entries(graphNode.children).forEach(([k, child]) => {
+      if (child.value.length < clusterMinSize) {
+        graphNode.value.push(...child.value);
+        graphNode.size += child.value.length;
+        child.size -= child.value.length;
+        child.value = [];
+        if (child.size === 0) {
+          delete graphNode.children[k];
+          console.error("delete", graphNode.path, k);
+          result = true;
         }
-        return [
-          {
-            path: originalCluster.path.concat([mf]),
-            files: newClusterFiles,
-            isLeftovers: false
-          },
-          {
-            path: originalCluster.path,
-            files: remainingFiles,
-            isLeftovers: true
-          }
-        ];
-      } else {
-        return [originalCluster];
       }
     });
+    return result;
   }
-  return clusterGroups.map((cluster) => {
+  graph2.bubbleMicroLeftovers = bubbleMicroLeftovers;
+  function unpackSmallest(graphNode, clusterMaxSize, clusterMinSize) {
+    let childrenSortedAsc = Object.entries(graphNode.children).sort((a, b) => a[1].size - b[1].size);
+    if (childrenSortedAsc.length === 0) {
+      return false;
+    }
+    let [k, child] = childrenSortedAsc[0];
+    let canFit = child.size + graphNode.value.length <= clusterMaxSize;
+    let cannotIsolate = graphNode.value.length < clusterMinSize;
+    if (canFit && cannotIsolate) {
+      graphNode.value.push(...flatten(child));
+      graphNode.size++;
+      delete graphNode.children[k];
+      console.error("delete", graphNode.path, k);
+      return true;
+    }
+    return false;
+  }
+  function bubbleMicroLeftoversRecursive(graphNode, clusterMaxSize, clusterMinSize) {
+    let changed = Object.values(graphNode.children).map((child) => {
+      bubbleMicroLeftoversRecursive(child, clusterMaxSize, clusterMinSize);
+    }).find(Boolean) || false;
+    changed = unpackSmallest(graphNode, clusterMaxSize, clusterMinSize) || changed;
+    changed = bubbleMicroLeftovers(graphNode, clusterMaxSize, clusterMinSize) || changed;
+    return changed;
+  }
+  graph2.bubbleMicroLeftoversRecursive = bubbleMicroLeftoversRecursive;
+  function collect(graphNode) {
+    let result = [];
+    function collectRecursive(node) {
+      result.push(node);
+      Object.values(node.children).forEach((child) => {
+        collectRecursive(child);
+      });
+    }
+    collectRecursive(graphNode);
+    return result;
+  }
+  graph2.collect = collect;
+})(graph || (graph = {}));
+function clusterFiles(files, clusterMaxSize, clusterMinSize) {
+  let fileInfos = files.sort().map((it) => {
+    let arr = it.split("/");
+    return { arr, str: it };
+  });
+  let graphNode = graph.buildGraph(fileInfos);
+  while (graph.bubbleMicroLeftoversRecursive(graphNode, clusterMaxSize, clusterMinSize)) {
+  }
+  let subclusters = graph.collect(graphNode).filter((it) => it.value.length > 0).sort((a, b) => b.path.join("/").localeCompare(a.path.join("/"))).map((it) => ({
+    path: it.path,
+    files: it.value,
+    isLeftovers: it.size > clusterMinSize,
+    isUnclusterable: it.size <= clusterMinSize
+  }));
+  return subclusters.map((cluster) => {
     let files2 = cluster.files;
-    let path5 = cluster.path;
+    let path4 = cluster.path;
     let files1 = files2.map((it) => it.str);
     return {
-      path: path5.join("/"),
-      files: files1,
+      path: path4.join("/"),
+      files: files1.sort(),
       weight: files1.length,
       isLeftovers: cluster.isLeftovers
     };
   });
 }
+// src/util/dataset.ts
+async function* distinctCount(source) {
+  const map = /* @__PURE__ */ new Map();
+  for await (const row of source) {
+    const key = JSON.stringify(row);
+    if (map.has(key)) {
+      map.get(key).count += 1;
+    } else {
+      map.set(key, { row, count: 1 });
+    }
+  }
+  for (const { row, count } of map.values()) {
+    yield [...row, count];
+  }
+}
 // src/index.ts
 var sigintCaught = false;
-function getDirectories(source) {
-  if (!fs4.existsSync(source) || !fs4.statSync(source).isDirectory()) return [];
+function getDirectories(absoluteDirPath) {
+  if (!fs3.existsSync(absoluteDirPath) || !fs3.statSync(absoluteDirPath).isDirectory()) return [];
   const ignoredDirs = /* @__PURE__ */ new Set([".git", "node_modules"]);
   try {
-    return fs4.readdirSync(source, { withFileTypes: true }).filter((dirent) => dirent.isDirectory() && !ignoredDirs.has(dirent.name)).map((dirent) => path4.join(source, dirent.name));
+    return fs3.readdirSync(absoluteDirPath, { withFileTypes: true }).filter((dirent) => dirent.isDirectory() && !ignoredDirs.has(dirent.name)).map((dirent) => path3.join(absoluteDirPath, dirent.name));
   } catch (error) {
-    console.error(`Could not read directory: ${source}`);
+    console.error(`Could not read directory: ${absoluteDirPath}`);
     return [];
   }
 }
-async function* forEachRepoFile(repoPath, doProcessFile) {
+async function* forEachRepoFile(repoRelativePath) {
   console.error(`
-Processing repository: ${repoPath || "."}`);
-  const originalCwd = process.cwd();
-  const discoveryPath = path4.resolve(originalCwd, repoPath);
-  if (!fs4.existsSync(discoveryPath)) {
-    console.error(`Error: Path does not exist: ${discoveryPath}. Skipping.`);
-    return;
-  }
-  const gitCommandPath = fs4.statSync(discoveryPath).isDirectory() ? discoveryPath : path4.dirname(discoveryPath);
-  let repoRoot;
-  try {
-    repoRoot = (0, import_child_process2.execSync)("git rev-parse --show-toplevel", { cwd: gitCommandPath, stdio: "pipe" }).toString().trim();
-  } catch (e) {
-    console.error(`Error: Could not find git repository at ${gitCommandPath}. Skipping.`);
-    return;
-  }
-  const repoName = path4.basename(repoRoot);
-  let revisionBoundary = await findRevision(repoRoot, 1e3);
-  const finalTargetPath = path4.relative(repoRoot, discoveryPath);
-  const { stdout: lsFilesOut } = await execAsync(
-    "git",
-    ["ls-files", "--", finalTargetPath || "."],
-    { cwd: repoRoot }
-  );
-  const files = lsFilesOut.filter((line) => line && line.length > 0);
-  let minClusterSize = Math.floor(Math.max(5, files.length / 1e3));
-  let maxClusterSize = Math.round(Math.max(20, minClusterSize * 2));
+Processing repository: ${repoRelativePath || "."}`);
+  const absoluteRepoPath = path3.resolve(process.cwd(), repoRelativePath);
+  const repoName = path3.basename(absoluteRepoPath);
+  let revisionBoundary = await findRevision(absoluteRepoPath, 5e3);
+  const files = await git_ls_files(absoluteRepoPath, ".");
+  let minClusterSize = Math.floor(Math.max(2, files.length / 100));
+  let maxClusterSize = Math.round(Math.max(20, files.length / 30));
   console.error(`Clustering ${files.length} into ${minClusterSize}..${maxClusterSize}+ sized chunks`);
   const filesClustered = clusterFiles(
     files,
     maxClusterSize,
     minClusterSize
   );
-  console.error(filesClustered.map((it) => `${it.path}${it.isLeftovers ? "/*" : ""} (${it.weight})`));
+  console.error(filesClustered.map((it) => `${it.path} (${it.weight})`));
   let clusterPaths = filesClustered.map((it) => it.path);
   console.error(`Found ${files.length} files to analyze in '${repoName}'...`);
   let filesShuffled = [...files].sort(() => Math.random() - 0.5);
@@ -667,7 +976,7 @@ Processing repository: ${repoPath || "."}`);
     process.stderr.write(progressMessage.padEnd(process.stderr.columns || 80, " ") + "\r");
     try {
       let clusterPath = clusterPaths.find((it) => file.startsWith(it)) ?? "$$$unknown$$$";
-      yield* (await doProcessFile(repoRoot, file, revisionBoundary)).map((it) => it.concat(clusterPath));
+      yield [absoluteRepoPath, file, revisionBoundary, clusterPath];
     } catch (e) {
       if (e.signal === "SIGINT") sigintCaught = true;
     }
@@ -675,68 +984,51 @@ Processing repository: ${repoPath || "."}`);
   process.stderr.write(" ".repeat(process.stderr.columns || 80) + "\r");
   console.error(`Analysis complete for '${repoName}'.`);
 }
-function daysAgo(epoch) {
-  const now = Date.now();
-  const diff = now - epoch * 1e3;
-  return Math.floor(diff / (1e3 * 60 * 60 * 24));
-}
-function bucket(n, buckets) {
-  for (let i = 1; i < buckets.length; i++) {
-    if (n > buckets[i - 1] && n < buckets[i]) return buckets[i - 1];
-  }
-  return -1;
-}
-async function doProcessFile1(repoRoot, filePath, revisionBoundary) {
-  if (!filePath) return [];
-  const absPath = path4.join(repoRoot, filePath);
+async function doProcessFile(absoluteRepoRoot, repoRelativeFilePath, revisionBoundary) {
+  if (!repoRelativeFilePath) return [];
+  const absoluteFilePath = path3.join(absoluteRepoRoot, repoRelativeFilePath);
   let stat = null;
   try {
-    stat = fs4.statSync(absPath);
+    stat = fs3.statSync(absoluteFilePath);
   } catch (e) {
-    console.error(`Fail get stats for file ${absPath}`, e.stack || e.message || e);
+    console.error(`Fail get stats for file ${absoluteFilePath}`, e.stack || e.message || e);
   }
   if (!stat || !stat.isFile() || stat.size === 0) return [];
   const result = [];
-  for (const item of await git_blame_porcelain(filePath, repoRoot, ["author", "committer-time", "commit"], revisionBoundary + "..HEAD")) {
+  for (const item of await git_blame_porcelain(repoRelativeFilePath, absoluteRepoRoot, ["author", "committer-time", "commit"], !!revisionBoundary ? revisionBoundary + "..HEAD" : void 0)) {
     if (revisionBoundary === item[2]) {
       item[0] = "?";
       item[1] = 0;
       item[2] = "0".repeat(40);
     }
-    const lang = path4.extname(filePath) || "Other";
-    let days_bucket = bucket(daysAgo(item[1]), [0, 30, 300, 1e3, 1e6]);
+    const lang = path3.extname(repoRelativeFilePath) || "Other";
+    let days_bucket = util.yyyyMM(item[1]);
     if (days_bucket != -1) {
-      result.push([item[0], days_bucket, lang, filePath, repoRoot]);
+      result.push([item[0], days_bucket, lang, repoRelativeFilePath, absoluteRepoRoot]);
     }
   }
   return result;
 }
-async function* distinctCount(source) {
-  const map = /* @__PURE__ */ new Map();
-  for await (const row of source) {
-    const key = JSON.stringify(row);
-    if (map.has(key)) {
-      map.get(key).count += 1;
-    } else {
-      map.set(key, { row, count: 1 });
-    }
-  }
-  for (const { row, count } of map.values()) {
-    yield [...row, count];
-  }
-}
 function getRepoPathsToProcess(inputPaths) {
   let repoPathsToProcess = inputPaths.flatMap((it) => findRepositories(it, 3));
-  repoPathsToProcess = [...new Set(repoPathsToProcess)].sort();
+  repoPathsToProcess = util.distinct(repoPathsToProcess).sort();
   if (repoPathsToProcess.length === 0) {
     throw new Error("No git repositories found to analyze.");
   }
   console.error(`Found ${repoPathsToProcess.length} repositories to analyze:`);
-  repoPathsToProcess.forEach((p) => console.error(`- ${p || "."}`));
+  repoPathsToProcess.forEach((p) => console.error(`- ${p ?? "."}`));
   return repoPathsToProcess;
 }
+function runScan1(args) {
+  const inputPaths = args && args.length > 0 ? args : ["."];
+  let repoPathsToProcess = getRepoPathsToProcess(inputPaths);
+  let dataSet = streamOf(AsyncGeneratorUtil.of(repoPathsToProcess)).flatMap((repoRelativePath) => forEachRepoFile(repoRelativePath)).flatMap((fileInfo) => {
+    let linesInfo = stream.ofArrayPromise(doProcessFile(fileInfo[0], fileInfo[1], fileInfo[2]));
+    return linesInfo.map((it) => it.concat(fileInfo[3])).get();
+  }).map((it) => [it[0], it[1], it[2], it[5], path3.basename(it[4])]).get();
+  return distinctCount(dataSet);
+}
 async function runScan(args) {
-  const tmpVfs = new RealFileSystemImpl("./.git-stats/");
   process.on("SIGINT", () => {
     if (sigintCaught) {
       console.error("\nForcing exit.");
@@ -745,23 +1037,19 @@ async function runScan(args) {
     sigintCaught = true;
     console.error("\nSignal received. Finishing current file then stopping. Press Ctrl+C again to exit immediately.");
   });
-  const inputPaths = args && args.length > 0 ? args : ["."];
-  let repoPathsToProcess = getRepoPathsToProcess(inputPaths);
-  await tmpVfs.write("data.jsonl", "");
-  let dataSet = new AsyncIteratorWrapperImpl(AsyncGeneratorUtil.of(repoPathsToProcess)).flatMap((repoPath) => forEachRepoFile(repoPath, doProcessFile1)).map((it) => [it[0], it[1], it[2], it[5], path4.basename(it[4])]).get();
-  let aggregatedData1 = distinctCount(dataSet);
+  let aggregatedData1 = runScan1(args);
   let aggregatedData = await AsyncGeneratorUtil.collect(aggregatedData1);
   aggregatedData.forEach((it) => console.log(JSON.stringify(it)));
 }
 async function runHtml(args) {
-  const inputPath = args[0] || path4.resolve("./.git-stats/data.jsonl");
-  const outHtml = path4.resolve("./.git-stats/report.html");
-  if (!fs4.existsSync(inputPath)) {
-    console.error(`Input data file not found: ${inputPath}`);
+  const absoluteInputPath = args[0] || path3.resolve("./.git-stats/data.jsonl");
+  const absoluteOutHtml = path3.resolve("./.git-stats/report.html");
+  if (!fs3.existsSync(absoluteInputPath)) {
+    console.error(`Input data file not found: ${absoluteInputPath}`);
     process.exitCode = 1;
     return;
   }
-  const lines = fs4.readFileSync(inputPath, "utf8").split(/\r?\n/).filter(Boolean);
+  const lines = fs3.readFileSync(absoluteInputPath, "utf8").split(/\r?\n/).filter(Boolean);
   const aggregatedData = lines.map((line) => {
     try {
       return JSON.parse(line);
@@ -769,29 +1057,71 @@ async function runHtml(args) {
       return null;
     }
   }).filter(Boolean);
-  generateHtmlReport(aggregatedData, outHtml);
-  console.error(`HTML report generated: ${outHtml}`);
+  generateHtmlReport(aggregatedData, absoluteOutHtml);
+  console.error(`HTML report generated: ${absoluteOutHtml}`);
 }
-function findRepositories(path5, depth) {
+function findRepositories(absolutePath, depth) {
   if (depth <= 0) return [];
-  if (!fs4.existsSync(path5)) throw new Error(`Path does not exist: ${path5}`);
-  if (!fs4.statSync(path5).isDirectory()) return [];
-  if (isGitRepo(path5)) return [path5];
-  let result = getDirectories(path5).flatMap((dir) => findRepositories(dir, depth - 1));
-  return [...new Set(result)].sort();
+  if (!fs3.existsSync(absolutePath)) throw new Error(`Path does not exist: ${absolutePath}`);
+  if (!fs3.statSync(absolutePath).isDirectory()) return [];
+  if (isGitRepo(absolutePath)) return [absolutePath];
+  let result = getDirectories(absolutePath).flatMap((dir) => findRepositories(dir, depth - 1));
+  return util.distinct(result).sort();
 }
 async function main() {
   const argv = process.argv.slice(2);
-  const isHtml = argv[0] === "html";
-  const subArgs = isHtml ? argv.slice(1) : argv;
-  if (isHtml) {
-    await runHtml(subArgs);
-  } else {
-    await runScan(subArgs);
+  let subcommand = argv[0];
+  let subcommandsMenu = {
+    "html": {
+      description: "Generates an HTML report from the aggregated data.",
+      usage: "git-stats html [input-data-file]"
+    },
+    "scan": {
+      description: "Scans a directory tree for Git repositories and generates aggregated data.",
+      usage: "git-stats scan [input-dir] > {output-file}.jsonl"
+    }
+  };
+  if (subcommand === "scan") {
+    await runScan(argv.slice(1));
+    return;
+  }
+  if (subcommand === "html") {
+    await runHtml(argv.slice(1));
+    return;
+  }
+  console.error(`Usage: git-stats <subcommand> [args]
+Available subcommands:`);
+  for (const [name, { description, usage }] of Object.entries(subcommandsMenu)) {
+    console.error(`- ${name}: ${description}
+    Usage: ${usage}`);
   }
 }
+var util;
+((util2) => {
+  function distinct(arr) {
+    return [...new Set(arr)];
+  }
+  util2.distinct = distinct;
+  function daysAgo(epoch) {
+    const now = Date.now();
+    const diff = now - epoch * 1e3;
+    return Math.floor(diff / (1e3 * 60 * 60 * 24));
+  }
+  util2.daysAgo = daysAgo;
+  function bucket(n, buckets) {
+    for (let i = 1; i < buckets.length; i++) {
+      if (n > buckets[i - 1] && n < buckets[i]) return buckets[i - 1];
+    }
+    return -1;
+  }
+  util2.bucket = bucket;
+  function yyyyMM(epoch) {
+    const date = new Date(epoch * 1e3);
+    let yyyyStr = date.getFullYear().toString();
+    let MMStr = (date.getMonth() + 1 / 4).toString().padStart(1, "0");
+    return parseInt(yyyyStr) * 10 + parseInt(MMStr);
+  }
+  util2.yyyyMM = yyyyMM;
+})(util || (util = {}));
 main().catch(console.error);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  distinctCount
-});

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@vladimirshefer/git-stats",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "A CLI to generate git blame stats for a repository",
   "main": "dist/index.js",
   "bin": {