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

@vladimirshefer/git-stats 0.0.1

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 +797 -0
package/package.json +28 -0

package/dist/index.js ADDED Viewed

@@ -0,0 +1,797 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  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"));
+// src/output/report_template.ts
+var path = __toESM(require("path"));
+var fs = __toESM(require("fs"));
+// src/output/report_template.html
+var report_template_default = `<!DOCTYPE html>
+<!--suppress TypeScriptMissingConfigOption -->
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Git Blame Statistics</title>
+    <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>
+    <!-- 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>
+<script type="text/babel" data-presets="react">
+    const RAW_DATASET =
+        __DATASET_JSON__
+        || [];
+    // Fixed schema as per pipeline: [author, days_bucket, lang, clusterPath, repoName, count]
+    const HEADER_LABELS = ["author", "days_bucket", "lang", "clusterPath", "repoName", "count"];
+    // -------- Client-side grouping/filtering engine --------
+    const KEY_INDEX = Object.fromEntries(HEADER_LABELS.map((k, i) => [k, i]));
+    const COUNT_IDX_FROM_END = 1; // last element is count
+    const allKeys = HEADER_LABELS.filter(k => k !== 'count');
+    const TOP_N = 20;
+    const BUCKET_COLORS = [
+        'rgba(214, 40, 40, 0.7)',
+        'rgba(247, 127, 0, 0.7)',
+        'rgba(252, 191, 73, 0.7)',
+        'rgba(168, 218, 142, 0.7)',
+        'rgba(75, 192, 192, 0.7)',
+        'rgba(54, 162, 235, 0.7)',
+        'rgba(153, 102, 255, 0.7)',
+        'rgba(201, 203, 207, 0.7)'
+    ];
+    function uniqueValues(arr, idx) {
+        const set = new Set(arr.map(r => r[idx]));
+        return Array.from(set);
+    }
+    function pivot(
+        dataset,
+        primaryKeyIndex,
+        secondaryKeyIndex,
+        filterState
+    ) {
+        const pivot = new Map();
+        const totals = 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 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);
+        }
+        const primaryKeys = Array.from(pivot.keys()).sort((a, b) => (totals.get(b) || 0) - (totals.get(a) || 0));
+        const secondaryKeys = Array.from(secValuesSet).sort((a, b) => String(a).localeCompare(String(b)));
+        return {pivot, totals, primaryKeys, secondaryKeys};
+    }
+    // ---------- 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;
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+            return () => {
+                chartRef.current && chartRef.current.destroy();
+            };
+        }, []);
+        React.useEffect(() => {
+            if (!chartRef.current) return;
+            chartRef.current.data.labels = labels;
+            chartRef.current.data.datasets = datasets;
+            chartRef.current.update();
+        }, [labels, datasets]);
+        return <canvas ref={canvasRef}/>;
+    }
+    function MultiSelect({label, values, selectedSet, onChange}) {
+        const selCount = selectedSet.size;
+        const total = values.length;
+        return (
+            <div>
+                <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));
+                    }}
+                >
+                    {values.map(v => {
+                        const strVal = String(v);
+                        return (
+                            <option key={strVal} value={strVal} selected={selectedSet.has(strVal)}>
+                                {strVal}
+                            </option>
+                        );
+                    })}
+                </select>
+            </div>
+        );
+    }
+    function App() {
+        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;
+            }
+            return {initialFilters: filters, valueOptions: options};
+        }, []);
+        const [filters, setFilters] = React.useState(initialFilters);
+        const [primaryKeyIndex, setPrimaryKeyIndex] = React.useState(0);
+        const [secondaryKeyIndex, setSecondaryKeyIndex] = React.useState(1);
+        const {chartLabels, datasets} = React.useMemo(() => {
+            const {
+                pivot: pv,
+                primaryKeys,
+                secondaryKeys
+            } = pivot(RAW_DATASET, primaryKeyIndex, secondaryKeyIndex, filters);
+            const chartPrimaryKeys = primaryKeys.slice(0, TOP_N);
+            const ds = secondaryKeys.map((sk, i) => ({
+                label: String(sk),
+                data: chartPrimaryKeys.map(pk => (pv.get(pk)?.get(sk)) || 0),
+                backgroundColor: BUCKET_COLORS[i % BUCKET_COLORS.length]
+            }));
+            return {chartLabels: chartPrimaryKeys, datasets: ds};
+        }, [filters, primaryKeyIndex, secondaryKeyIndex]);
+        return (
+            <div className="max-w-4xl mx-auto my-5 p-5 bg-white rounded-lg shadow-sm">
+                <h1 className="border-b border-gray-300 pb-2.5">Git Contribution Statistics</h1>
+                <div className="controls">
+                    <h2 className="border-b border-gray-300 pb-2.5">Controls</h2>
+                    <div className="flex gap-4 flex-wrap items-center">
+                        <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>
+                                ))}
+                            </select>
+                        </label>
+                        <label>
+                            Secondary group:
+                            <select value={secondaryKeyIndex}
+                                    onChange={e => setSecondaryKeyIndex(Number(e.target.value))}>
+                                {allKeys.map((__, i) => (
+                                    <option key={i} value={i}>{HEADER_LABELS[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) => (
+                            <MultiSelect
+                                key={idx}
+                                label={HEADER_LABELS[idx]}
+                                values={valueOptions[key]}
+                                selectedSet={filters[key]}
+                                onChange={(newSet) => setFilters(prev => ({...prev, [key]: 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>
+            </div>
+        );
+    }
+    const root = ReactDOM.createRoot(document.getElementById('root'));
+    root.render(<App/>);
+</script>
+</body>
+</html>
+`;
+// src/output/report_template.ts
+function generateHtmlReport(data, outputFile) {
+  const finalOutputPath = path.join(outputFile);
+  let htmlContent = report_template_default.split("__DATASET_JSON__");
+  fs.writeFileSync(finalOutputPath, htmlContent[0]);
+  fs.appendFileSync(finalOutputPath, "\n[\n");
+  for (let i = 0; i < data.length; i++) {
+    fs.appendFileSync(finalOutputPath, JSON.stringify(data[i]) + ",\n");
+  }
+  fs.appendFileSync(finalOutputPath, "\n]\n");
+  fs.appendFileSync(finalOutputPath, htmlContent[1]);
+}
+// src/git.ts
+var import_path = __toESM(require("path"));
+var import_fs = __toESM(require("fs"));
+async function executeGitBlamePorcelain(file, repoRoot, revisionBoundary, since) {
+  const args = ["blame", "--line-porcelain"];
+  if (since) {
+    args.push(`--since=${since}`);
+  }
+  if (revisionBoundary) {
+    args.push(revisionBoundary);
+  }
+  args.push("--", file);
+  const { stdout } = await execAsync("git", args, { cwd: repoRoot });
+  return stdout;
+}
+async function git_blame_porcelain(file, repoRoot, fields, revisionBoundary) {
+  const blameOutput = await executeGitBlamePorcelain(file, repoRoot, revisionBoundary);
+  return parsePorcelain(blameOutput, fields);
+}
+function parsePorcelain(blameOutput, fields) {
+  const userPos = fields.indexOf("author");
+  const commiterTimePos = fields.indexOf("committer-time");
+  const boundaryPos = fields.indexOf("boundary");
+  const commitPos = fields.indexOf("commit");
+  let emptyRow = [...fields];
+  if (commiterTimePos >= 0) {
+    emptyRow[commiterTimePos] = 0;
+  }
+  if (boundaryPos >= 0) {
+    emptyRow[boundaryPos] = 0;
+  }
+  let nextRow = [...emptyRow];
+  const result = [];
+  for (const line of blameOutput) {
+    if (line.startsWith("	")) {
+      result.push([...nextRow]);
+      continue;
+    }
+    if (commitPos >= 0) {
+      const firstSpace = line.indexOf(" ");
+      if (firstSpace === 40) {
+        const possibleHash = line.substring(0, firstSpace);
+        if (/^\^?[0-9a-f]{40}$/i.test(possibleHash)) {
+          nextRow = [...emptyRow];
+          nextRow[commitPos] = possibleHash.replace(/^\^/, "");
+          continue;
+        }
+      }
+    }
+    if (userPos >= 0 && line.startsWith("author ")) {
+      nextRow[userPos] = line.substring("author ".length).replace(/^<|>$/g, "");
+      continue;
+    }
+    if (commiterTimePos >= 0 && line.startsWith("committer-time ")) {
+      nextRow[commiterTimePos] = parseInt(line.substring("committer-time ".length), 10);
+      continue;
+    }
+    if (boundaryPos >= 0 && line.startsWith("boundary")) {
+      nextRow[boundaryPos] = 1;
+    }
+  }
+  return result;
+}
+function isGitRepo(dir) {
+  return import_fs.default.existsSync(import_path.default.join(dir, ".git"));
+}
+async function findRevision(repoRoot, commitsBack) {
+  let n = commitsBack;
+  try {
+    const { stdout } = await execAsync("git", [
+      "rev-list",
+      "--max-count=1",
+      "--skip=" + n,
+      "HEAD"
+    ], { cwd: repoRoot });
+    return stdout.join("\n").trim();
+  } catch (e) {
+    if (e && (e.stack || e.message)) {
+      console.error(`Failed to compute ${n}-commit boundary for repo ${repoRoot}:`, e.message || e.stack);
+    }
+  }
+  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}`);
+  }
+};
+// src/util/AsyncGeneratorUtil.ts
+var AsyncGeneratorUtil = class {
+  static async *of(items) {
+    for (const item of items) {
+      yield item;
+    }
+  }
+  static async *flatMap(items, mapper) {
+    for await (const item of items) {
+      yield* mapper(item);
+    }
+  }
+  static async *union(sources) {
+    for (const source of sources) {
+      yield* source;
+    }
+  }
+  static async *map(source, mapper) {
+    for await (const item of source) {
+      yield mapper(item);
+    }
+  }
+  static async *peek(source, consumer) {
+    for await (const item of source) {
+      consumer(item);
+      yield item;
+    }
+  }
+  static async collect(source) {
+    const result = [];
+    const iterator = source[Symbol.asyncIterator]();
+    return new Promise((resolve2, reject) => {
+      function step() {
+        iterator.next().then(({ value, done }) => {
+          if (done) {
+            resolve2(result);
+          } else {
+            result.push(value);
+            step();
+          }
+        }).catch(reject);
+      }
+      step();
+    });
+  }
+};
+var AsyncIteratorWrapperImpl = class _AsyncIteratorWrapperImpl {
+  constructor(source) {
+    this.source = source;
+  }
+  get() {
+    return this.source;
+  }
+  map(mapper) {
+    return new _AsyncIteratorWrapperImpl(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));
+  }
+  async forEach(consumer) {
+    for await (const item of this.source) {
+      await consumer(item);
+    }
+  }
+};
+// 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;
+      }
+    }
+    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
+            }
+          ];
+        }
+        if (newClusterFiles.length < clusterMinSize || remainingFiles.length < clusterMinSize) {
+          return [{ ...originalCluster, isUnclusterable: true }];
+        }
+        return [
+          {
+            path: originalCluster.path.concat([mf]),
+            files: newClusterFiles,
+            isLeftovers: false
+          },
+          {
+            path: originalCluster.path,
+            files: remainingFiles,
+            isLeftovers: true
+          }
+        ];
+      } else {
+        return [originalCluster];
+      }
+    });
+  }
+  return clusterGroups.map((cluster) => {
+    let files2 = cluster.files;
+    let path5 = cluster.path;
+    let files1 = files2.map((it) => it.str);
+    return {
+      path: path5.join("/"),
+      files: files1,
+      weight: files1.length,
+      isLeftovers: cluster.isLeftovers
+    };
+  });
+}
+// src/index.ts
+var sigintCaught = false;
+function getDirectories(source) {
+  if (!fs4.existsSync(source) || !fs4.statSync(source).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));
+  } catch (error) {
+    console.error(`Could not read directory: ${source}`);
+    return [];
+  }
+}
+async function* forEachRepoFile(repoPath, doProcessFile) {
+  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));
+  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})`));
+  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);
+  for (let i = 0; i < files.length; i++) {
+    if (sigintCaught) break;
+    const file = filesShuffled[i];
+    const progressMessage = `[${i + 1}/${files.length}] Analyzing: ${file}`;
+    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));
+    } catch (e) {
+      if (e.signal === "SIGINT") sigintCaught = true;
+    }
+  }
+  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);
+  let stat = null;
+  try {
+    stat = fs4.statSync(absPath);
+  } catch (e) {
+    console.error(`Fail get stats for file ${absPath}`, 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")) {
+    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]);
+    if (days_bucket != -1) {
+      result.push([item[0], days_bucket, lang, filePath, repoRoot]);
+    }
+  }
+  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();
+  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 || "."}`));
+  return repoPathsToProcess;
+}
+async function runScan(args) {
+  const tmpVfs = new RealFileSystemImpl("./.git-stats/");
+  process.on("SIGINT", () => {
+    if (sigintCaught) {
+      console.error("\nForcing exit.");
+      process.exit(130);
+    }
+    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 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}`);
+    process.exitCode = 1;
+    return;
+  }
+  const lines = fs4.readFileSync(inputPath, "utf8").split(/\r?\n/).filter(Boolean);
+  const aggregatedData = lines.map((line) => {
+    try {
+      return JSON.parse(line);
+    } catch {
+      return null;
+    }
+  }).filter(Boolean);
+  generateHtmlReport(aggregatedData, outHtml);
+  console.error(`HTML report generated: ${outHtml}`);
+}
+function findRepositories(path5, 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();
+}
+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);
+  }
+}
+main().catch(console.error);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  distinctCount
+});

package/package.json ADDED Viewed

@@ -0,0 +1,28 @@
+{
+  "name": "@vladimirshefer/git-stats",
+  "version": "0.0.1",
+  "description": "A CLI to generate git blame stats for a repository",
+  "main": "dist/index.js",
+  "bin": {
+    "git-stats": "dist/index.js"
+  },
+  "files": [
+    "dist/**",
+    "README.md",
+    "LICENSE*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "node build.mjs",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "vitest": "^1.6.0",
+    "esbuild": "0.25.0",
+    "typescript": "^5.0.0"
+  }
+}