@adobe/sizewatcher 1.0.0 → 1.2.1

package/CHANGELOG.md

@@ -1,5 +1,40 @@
 # Changelog
 
+## 1.2.0
+
+Improvements:
+
+- [#41](https://github.com/adobe/sizewatcher/issues/41) Support project structures where package.json is in subdirectory. Introduces the `dir` config on comparators.
+
+Fixes:
+
+- [#46](https://github.com/adobe/sizewatcher/issues/46) Support running in a subdirectory of a git checkout.
+
+- [#43](https://github.com/adobe/sizewatcher/issues/43) `node_modules` comparator failed if there were no dependencies
+
+- [#42](https://github.com/adobe/sizewatcher/issues/42) `npm_package` failed if there was no version field in package.json
+
+## 1.1.0
+
+New Comparators:
+
+- [#14](https://github.com/adobe/sizewatcher/issues/14) npm package size
+
+Improvements:
+
+- [#32](https://github.com/adobe/sizewatcher/issues/32) Improved PR comment that can be collapsed as whole, shows the summary result and is collapsed by default if the result is ok.
+
+- [#33](https://github.com/adobe/sizewatcher/issues/33) Support `script` option in custom comparator. This allows to run build steps in case the output of those needs to be measured. The `path` option now also supports glob patterns.
+
+
+- [#31](https://github.com/adobe/sizewatcher/issues/31) Change default limits to make them less aggressive:
+  - fail: `100%`
+  - warn: `30%`
+  - ok: `-10%` (same)
+
+- [#39](https://github.com/adobe/sizewatcher/issues/39) Detect if comparing the same branch and exit gracefully.
+
+
 ## 1.0.0
 
 Initial version with comparators

package/README.md

@@ -10,7 +10,7 @@
 
 <!-- code_chunk_output -->
 
-- [Standard behavior](#standard-behavior)
+- [How it works](#how-it-works)
 - [Requirements](#requirements)
 - [Installation](#installation)
 - [Usage](#usage)
@@ -28,88 +28,94 @@
 - addition of large dependencies (and transient dependency trees)
 - accidental addition of large binary files to the git repository
 - sudden increase in build artifact size
-- etc.
 
-Currently supported are git repository size itself, Node.js/npm modules and measuring any custom files or folders - see [Comparators reference](#comparators-reference). More built-in languages & options are possible in the future.
+While any custom file or folder path can be measured via configuration, various types are automatically measured, including git repository, Node module dependencies and npm package size - see [comparators reference](#comparators-reference). More built-in languages & options are added over time and [contributions are welcome](#new-comparator).
 
-`sizewatcher` runs as part of your CI and reports results as comment on the pull request or as github commit status (optional), allowing to block PRs if a certain threshold was exceeded. This is an example of a Github PR comment:
+`sizewatcher` runs as part of your CI and reports results as comment on the pull request or as github commit status (optional), allowing to block PRs if a certain threshold was exceeded.
+
+This is an example of a `sizewatcher` Github PR comment with a failure (ignore the small numbers):
 
 ---
 
-📈 [Sizewatcher](https://github.com/adobe/sizewatcher) measured these changes:
+<details open><summary>❌ <a href="https://github.com/adobe/sizewatcher">Sizewatcher</a> detected a problematic size increase 📈:</summary>
+<p><blockquote>
 
-<details>
-<summary>✅ <code>git</code> <b>+0.2%</b> (246 kB => 247 kB)</summary>
-<br>
+<details><summary>❌ <code>git</code> <b>+97.9%</b> (186 kB => 368 kB)</summary><br>Largest files in new changes:<pre>ecaf42b1d55c  4.5KiB lib/report.js<br>9c1a82fa7efb  2.8KiB lib/render.js<br>710a7c687b06  2.8KiB lib/render.js<br>e7a5a58b23a6  2.7KiB test/config.test.js<br>0a8f1a2ddb4f  2.4KiB test/config.test.js<br>6846cf298cd4  2.3KiB test/config.test.js<br>461b7663fd23  1.6KiB lib/config.js<br>a643d322cc26  1.5KiB lib/config.js<br>6db7d5c27a66     69B .sizewatcher.yml</pre></details>
 
-Largest files in new changes:
-```
-360cccafa87c    974B .npmignore
-```
-</details>
+<details><summary>✅ <code>node_modules</code> <b>-6.1%</b> (42.5 MB => 39.9 MB)</summary><br>Largest node modules:<pre>┌───────────────┬─────────────┬────────┐<br>│ name          │ children    │ size   │<br>├───────────────┼─────────────┼────────┤<br>│ @octokit/rest │ 33          │ 11.25M │<br>├───────────────┼─────────────┼────────┤<br>│ js-yaml       │ 3           │ 0.72M  │<br>├───────────────┼─────────────┼────────┤<br>│ simple-git    │ 2           │ 0.24M  │<br>├───────────────┼─────────────┼────────┤<br>│ tmp           │ 13          │ 0.22M  │<br>├───────────────┼─────────────┼────────┤<br>│ debug         │ 1           │ 0.08M  │<br>├───────────────┼─────────────┼────────┤<br>│ deepmerge     │ 0           │ 0.03M  │<br>├───────────────┼─────────────┼────────┤<br>│ require-dir   │ 0           │ 0.02M  │<br>├───────────────┼─────────────┼────────┤<br>│ du            │ 1           │ 0.01M  │<br>├───────────────┼─────────────┼────────┤<br>│ pretty-bytes  │ 0           │ 0.01M  │<br>├───────────────┼─────────────┼────────┤<br>│ 9 modules     │ 34 children │ 4.57M  │<br>└───────────────┴─────────────┴────────┘</pre></details>
 
-<details>
-<summary>✅ <code>node_modules</code> has no changes (46.8 MB)</summary>
-<br>
+<details><summary>Notes</summary><br>
 
-Largest node modules:
-```
-┌───────────────┬─────────────┬────────┐
-│ name          │ children    │ size   │
-├───────────────┼─────────────┼────────┤
-│ @octokit/rest │ 33          │ 11.25M │
-├───────────────┼─────────────┼────────┤
-│ js-yaml       │ 3           │ 0.72M  │
-├───────────────┼─────────────┼────────┤
-│ simple-git    │ 2           │ 0.24M  │
-├───────────────┼─────────────┼────────┤
-│ tmp           │ 13          │ 0.22M  │
-├───────────────┼─────────────┼────────┤
-│ debug         │ 1           │ 0.08M  │
-├───────────────┼─────────────┼────────┤
-│ deepmerge     │ 0           │ 0.03M  │
-├───────────────┼─────────────┼────────┤
-│ require-dir   │ 0           │ 0.02M  │
-├───────────────┼─────────────┼────────┤
-│ du            │ 1           │ 0.01M  │
-├───────────────┼─────────────┼────────┤
-│ pretty-bytes  │ 0           │ 0.01M  │
-├───────────────┼─────────────┼────────┤
-│ 9 modules     │ 34 children │ 4.57M  │
-└───────────────┴─────────────┴────────┘
+- PR branch: `testconfig` @ 21b66dfe6c3f6d09d4929ea2dec1e62cd1a7e7f2
+- Base branch: `main`
+- Sizewatcher v1.0.0
+- Effective Configuration:
+
+```yaml
+limits:
+  fail: 100%
+  warn: 30%
+  ok: '-10%'
+report:
+  githubComment: true
+  githubStatus: false
+comparators:
+  git:
+    limits:
+      fail: 50%
+  custom: null
 ```
 </details>
 
-<details>
-<summary>Notes</summary>
-<br>
+</blockquote></p>
+</details>
+
+---
+
+And here if everything looks good:
+
+---
+
+<details ><summary>✅ <a href="https://github.com/adobe/sizewatcher">Sizewatcher</a> found no problematic size increases.</summary>
+<p><blockquote>
 
-- PR branch: `docs` @ 15626a050330492da8b745dadb4f5d304b670e83
+<details><summary>✅ <code>git</code> <b>+97.9%</b> (186 kB => 368 kB)</summary><br>Largest files in new changes:<pre>ecaf42b1d55c  4.5KiB lib/report.js<br>9c1a82fa7efb  2.8KiB lib/render.js<br>710a7c687b06  2.8KiB lib/render.js<br>e7a5a58b23a6  2.7KiB test/config.test.js<br>0a8f1a2ddb4f  2.4KiB test/config.test.js<br>6846cf298cd4  2.3KiB test/config.test.js<br>461b7663fd23  1.6KiB lib/config.js<br>a643d322cc26  1.5KiB lib/config.js<br>6db7d5c27a66     69B .sizewatcher.yml</pre></details>
+
+<details><summary>✅ <code>node_modules</code> <b>-6.1%</b> (42.5 MB => 39.9 MB)</summary><br>Largest node modules:<pre>┌───────────────┬─────────────┬────────┐<br>│ name          │ children    │ size   │<br>├───────────────┼─────────────┼────────┤<br>│ @octokit/rest │ 33          │ 11.25M │<br>├───────────────┼─────────────┼────────┤<br>│ js-yaml       │ 3           │ 0.72M  │<br>├───────────────┼─────────────┼────────┤<br>│ simple-git    │ 2           │ 0.24M  │<br>├───────────────┼─────────────┼────────┤<br>│ tmp           │ 13          │ 0.22M  │<br>├───────────────┼─────────────┼────────┤<br>│ debug         │ 1           │ 0.08M  │<br>├───────────────┼─────────────┼────────┤<br>│ deepmerge     │ 0           │ 0.03M  │<br>├───────────────┼─────────────┼────────┤<br>│ require-dir   │ 0           │ 0.02M  │<br>├───────────────┼─────────────┼────────┤<br>│ du            │ 1           │ 0.01M  │<br>├───────────────┼─────────────┼────────┤<br>│ pretty-bytes  │ 0           │ 0.01M  │<br>├───────────────┼─────────────┼────────┤<br>│ 9 modules     │ 34 children │ 4.57M  │<br>└───────────────┴─────────────┴────────┘</pre></details>
+
+<details><summary>Notes</summary><br>
+
+- PR branch: `testconfig` @ 21b66dfe6c3f6d09d4929ea2dec1e62cd1a7e7f2
 - Base branch: `main`
 - Sizewatcher v1.0.0
-- Configuration
-<pre>
+- Effective Configuration:
+
+```yaml
 limits:
-  fail: 50%
-  warn: 10%
+  fail: 100%
+  warn: 200%
   ok: '-10%'
 report:
   githubComment: true
   githubStatus: false
 comparators: {}
-</pre></details>
+```
+</details>
+
+</blockquote></p>
+</details>
 
 ---
 
-## Standard behavior
+## How it works
 
 By default `sizewatcher` will
 - checkout the before and after branch versions in temporary directories
 - go through all [comparators](#comparators-reference) that apply
 - measure the sizes, compare and report
-  - fail ❌ at a 50%+ increase
-  - warn ⚠️ at a 10%+ increase
-  - report ok ✅ if the size does not change by +/-10%
+  - fail ❌ at a 100%+ increase
+  - warn ⚠️ at a 30%+ increase
+  - report ok ✅ if the size change is between -10 and +30%
   - cheer 🎉 if there is a 10% decrease
 - print result in cli output
 - report result as PR comment
@@ -121,6 +127,8 @@ By default `sizewatcher` will
 
 - [Nodejs](https://nodejs.org) version 10+
   - recommended to use latest stable version "LTS"
+- Github or Github Enterprise
+  - if you want to run it on pull requests
 - CI system running on Github pull requests
   - [Github Actions](https://github.com/features/actions) (simplest setup)
   - [Travis CI](https://travis-ci.org)
@@ -147,7 +155,7 @@ sizewatcher -h
 
 Help output:
 ```
-Usage: /usr/local/bin/sizewatcher [<options>] [<before> [<after>]]
+Usage: sizewatcher [<options>] [<before> [<after>]]
 
 Arguments:
   <before>   Before branch/commit for comparison. Defaults to default branch or main/master.
@@ -203,18 +211,31 @@ sizewatcher before after
 
 ## CI Setup
 
+- [CI Overview](#ci-overview)
 - [Github Actions](#github-actions)
 - [Travis CI](#travis-ci)
 - [CircleCI](#circleci)
 - [Other CIs](#other-cis)
 
-To run `sizewatcher` in your CI, which is where it should run, it is best run using [npx](https://nodejs.dev/learn/the-npx-nodejs-package-runner), which comes pre-installed with nodejs and will automatically download and run the latest version in one go:
+### CI Overview
+
+#### Run using npx
+
+To run `sizewatcher` in your CI, which is where it needs to run automatically for checking pull requests, it is best run using [npx](https://nodejs.dev/learn/the-npx-nodejs-package-runner), which comes pre-installed with nodejs and will automatically download and run the latest version in one go:
 
 ```
 npx @adobe/sizewatcher
 ```
 
-Depending on the CI, branches of the pull request are automatically detected. Last but not least, to be able to automatically comment on the PR or report a commit status, a **github token** must be set as environment variable:
+This command will always use the latest published version. In some cases it might be (temporarily) desireable to stick to a certain version, which can be achieved using:
+
+```
+npx @adobe/sizewatcher@1.0.0
+```
+
+#### GITHUB_TOKEN
+
+To be able to automatically comment on the PR or report a commit status, a **github token** must be set as environment variable:
 
 ```
 GITHUB_TOKEN=....
@@ -222,6 +243,19 @@ GITHUB_TOKEN=....
 
 This token should be a service/bot user that has read/pull permission on the repository (allowing to comment). Note that the comments will be shown under that user's name. For example, you might want to create a user named `sizewatcher-bot` or the like. With Github Actions this is not required, it has a built-in `github-actions` bot user.
 
+#### GITHUB_API_URL
+
+If you use Github Enterprise, set the custom [Github API URL](https://docs.github.com/en/enterprise-server@2.21/rest/reference/enterprise-admin) in the `GITHUB_API_URL` environment variable:
+
+```
+GITHUB_API_URL=https://mygithub.company.com/api/v3/
+```
+
+This is not required for public github.com.
+
+#### Order of steps
+
+You can run `sizewatcher` before, after or in parallel to your main build step. It does not rely on output of a build, since it will check out the code (before and after PR versions) separately and needs to run any build steps itself, such as using `script` in the [custom comparator](#custom).
 
 See below for CI specific setup.
 
@@ -245,8 +279,6 @@ jobs:
       uses: actions/setup-node@v1
       with:
         node-version: '14'
-    # run your build/test first in case you want to measure build results
-    - run: npm install && npm test
     # ---------- this runs sizewatcher ------------
     - run: npx @adobe/sizewatcher
       env:
@@ -258,7 +290,7 @@ jobs:
 For [Travis CI](https://travis-ci.org) you need to
 - use `language: node_js`
   - if you already use a different language, find a way to ensure Nodejs 10+ is installed
-- under `script` run `npx @adobe/sizewatcher`, typically after your main build or test
+- under `script` run `npx @adobe/sizewatcher`
 - set a secret environment variable `GITHUB_TOKEN` in the [Travis repository settings](https://docs.travis-ci.com/user/environment-variables/#defining-variables-in-repository-settings) with a github token with permission to comment on PRs and reporting commit statuses for the repository
 
 Example `.travis.yml`:
@@ -270,8 +302,6 @@ install:
   - npm install
 
 script:
-  # run your build/test first in case you want to measure build results
-  - npm test
   # ---------- this runs sizewatcher ------------
   - npx @adobe/sizewatcher
 ```
@@ -281,7 +311,7 @@ script:
 For [CircleCI](https://circleci.com) you need to
 - use a docker image with Nodejs 10+ installed
   - alternatively install [using nvm](https://www.google.com/search?q=circleci+use+nvm)
-- run `npx @adobe/sizewatcher`, typically after your main build or test
+- run `npx @adobe/sizewatcher`
 - set a secret environment variable `GITHUB_TOKEN` in the [CircleCI project settings](https://circleci.com/docs/2.0/env-vars/#setting-an-environment-variable-in-a-project) (or in a [Context](https://circleci.com/docs/2.0/env-vars/#setting-an-environment-variable-in-a-context)) with a github token with permission to comment on PRs and reporting commit statuses for the repository
 
 Example `.circleci/config.yml`:
@@ -296,10 +326,6 @@ jobs:
     steps:
       - checkout
 
-      # run your build/test first in case you want to measure build results
-      - run: npm install
-      - run: npm test
-
       # ---------- this runs sizewatcher ------------
       - run: npx @adobe/sizewatcher
 ```
@@ -316,7 +342,7 @@ Set these environment variables in the CI job:
 - `GITHUB_HEAD_REF` name of the branch of the pull request
 - `GITHUB_TOKEN` a github token with permission to comment on PRs and reporting commit statuses for the repository. This is a credential so use the proper CI credential management and never check this into the git repository!
 
-After your build or in parallel, run
+Then simply run
 
 ```
 npx @adobe/sizewatcher
@@ -345,10 +371,10 @@ report:
 #   see https://www.npmjs.com/package/xbytes
 # - absolute limit, as byte number: 1000000
 limits:
-  # when to fail - default: 50%
+  # when to fail - default: 100%
   fail: 50%
-  # when to warn - default: 10%
-  warn: 30%
+  # when to warn - default: 30%
+  warn: 10%
   # below the ok limit you will get a cheers for making it notably smaller
   # default: -10%
   ok: -5%
@@ -369,6 +395,15 @@ comparators:
       warn: 9 MB
       ok: 1 MB
 
+  npm_package:
+    # `dir` is supported for all comparators that support it and
+    # specifies the relative directory inside the project inside which to run the comparator
+    dir: "sub/folder"
+    # can also be an array with multiple directories to check
+    dir:
+      - "sub/folder1"
+      - "folder2"
+
   # custom comparator (only active if configured)
   custom:
     - name: my artifact
@@ -379,7 +414,10 @@ comparators:
 
     # there can be multiple custom comparators
     # name defaults to the path
-    - path: some_directory/
+    # path can include glob patterns
+    - path: "artifact-*.tgz"
+      # run some custom build command before measuring
+      script: npm install
       # limits can be configured as well
       limits:
         fail: 10 MB
@@ -389,6 +427,7 @@ comparators:
 
 - [git](#git)
 - [node_modules](#node_modules)
+- [npm_package](#npm_package)
 - [custom](#custom)
 
 ### git
@@ -451,6 +490,52 @@ Largest node modules:
 └───────────────┴─────────────┴────────┘
 ```
 
+Configuration: supports `dir`
+
+---
+
+### npm_package
+
+Compares the size of an npm package tarball by running `npm publish --dry-run`.
+
+Name: `npm_package`
+
+Trigger: Runs if a `package.json` is found.
+
+Details: Prints the package contents and metadata using the output of `npm publish --dry-run`.
+
+---
+Package contents:
+
+```
+📦  @adobe/sizewatcher@1.0.0
+=== Tarball Contents ===
+11.3kB LICENSE
+4.8kB  lib/checkout.js
+5.2kB  lib/compare.js
+1.7kB  lib/config.js
+3.9kB  lib/comparators/custom.js
+2.3kB  lib/comparators/git.js
+2.6kB  lib/github.js
+2.1kB  index.js
+2.2kB  lib/comparators/node_modules.js
+3.9kB  lib/render.js
+4.6kB  lib/report.js
+1.1kB  package.json
+695B   CHANGELOG.md
+23.9kB README.md
+=== Tarball Details ===
+name:          @adobe/sizewatcher
+version:       1.0.0
+package size:  18.6 kB
+unpacked size: 70.3 kB
+shasum:        80846caccca2194f3dd1122e8113206e20c202dc
+integrity:     sha512-c3VjMQQvqcqN8[...]ybMS6kg2chjpA==
+total files:   14
+```
+
+Configuration: supports `dir`
+
 ---
 
 ### custom
@@ -479,7 +564,16 @@ This comparator requires configuration in the `.sizewatcher.yml`:
 ```yaml
 comparators:
   custom:
-    path: build/artifact
+    path: src/somefile
+```
+
+If a build step is required first, use `script`:
+
+```yaml
+comparators:
+  custom:
+    path: "build/artifact-*.tgz"
+    script: npm run build
 ```
 
 To have multiple paths, with custom names:
@@ -488,14 +582,15 @@ To have multiple paths, with custom names:
 comparators:
   custom:
     - name: my artifact 1
-      path: build/artifact
+      path: "build/artifact"
     - name: my artifact 2
-      path: build/artifact2
+      path: "build/artifact2"
 ```
 
 Options:
-- `path` (required) relative path to file or folder to measure
+- `path` (required) relative path to file or folder to measure; supports [glob patterns](https://www.npmjs.com/package/glob). make sure to use quotes in the yaml if you use glob patterns
 - `name` (optional) custom label
+- `script` (optional) shell command to run before measuring `path`
 - `limits` can be set as usual
 
 ## Contribute

package/index.js

@@ -14,50 +14,5 @@
 
 'use strict';
 
-// index.js - main cli entry point
-
-const gitCheckoutBeforeAndAfter = require("./lib/checkout");
-const compare = require("./lib/compare");
-const report = require("./lib/report");
-
-function printUsage() {
-    console.log(`Usage: ${process.argv[1]} [<options>] [<before> [<after>]]`);
-    console.log();
-    console.log("Arguments:");
-    console.log("  <before>   Before branch/commit for comparison. Defaults to default branch or main/master.");
-    console.log("  <after>    After branch/commit for comparison. Defaults to current branch.");
-    console.log();
-    console.log("Options:");
-    console.log("  -h     Show help");
-}
-
-async function main(argv) {
-    try {
-        // yes, this should probably use a framework like oclif or yargs.
-        // but cli arguments are very limited now and so manual handling is enough
-        if (argv[0] === "-h") {
-            printUsage();
-            process.exit(1);
-        }
-
-        // TODO: detect main = main case
-
-        console.log(`Cloning git repository...`);
-        const { before, after } = await gitCheckoutBeforeAndAfter(process.cwd(), argv[0], argv[1]);
-
-        console.log(`Comparing changes from '${before.branch}' to '${after.branch}'\n`);
-
-        const deltas = await compare(before, after);
-
-        await report(deltas);
-
-    } catch (e) {
-        console.error(e);
-        process.exit(1);
-    } finally {
-        console.log("Done. Cleaning up...");
-    }
-}
-
-
-main(process.argv.slice(2));
+const sizewatcher = require("./lib/sizewatcher");
+sizewatcher(process.argv.slice(2));

package/lib/checkout.js

@@ -18,7 +18,13 @@ const debug = require("debug")("sizewatcher");
 const tmp = require("tmp");
 tmp.setGracefulCleanup();
 const path = require("path");
-const Git = require("simple-git/promise");
+const Git = require("simple-git");
+
+async function getGitRoot(dir) {
+    // --git-dir will return relative directories
+    const gitRootDir = await Git(dir).revparse(["--git-dir"]);
+    return path.resolve(dir, gitRootDir);
+}
 
 async function currentBranch(dir) {
     const git = Git(dir);
@@ -37,10 +43,14 @@ async function currentSha(dir) {
 }
 
 async function getDefaultBranch(dir) {
-    const originInfo = await Git(dir).remote(["show", "origin"]);
-    const m = originInfo.match(/HEAD branch: (.*)$/m);
-    if (m) {
-        return m[1];
+    try {
+        const originInfo = await Git(dir).remote(["show", "origin"]);
+        const m = originInfo.match(/HEAD branch: (.*)$/m);
+        if (m) {
+            return m[1];
+        }
+    } catch (e) {
+        debug(`ignoring error in getDefaultBranch(): ${e.message}`);
     }
 }
 
@@ -48,22 +58,12 @@ async function hasBranch(dir, branch) {
     try {
         await Git(dir).revparse(["--verify", branch]);
         return branch;
-    } catch (e) { // eslint-disable-line no-unused-vars
+    } catch (e) {
+        debug(`ignoring error in hasBranch(): ${e.message}`);
         return undefined;
     }
 }
 
-async function hasRemoteTrackingBranch(dir) {
-    const git = Git(dir);
-    try {
-        const remoteBranch = await git.revparse(["--abbrev-ref", "--symbolic-full-name", "@{u}"]);
-        console.log(remoteBranch);
-        return true;
-    } catch (e) { // eslint-disable-line no-unused-vars
-        return false;
-    }
-}
-
 async function getPullRequestBaseBranch() {
     return process.env.GITHUB_BASE_REF
         || (process.env.TRAVIS_PULL_REQUEST !== "false" && process.env.TRAVIS_BRANCH);
@@ -101,36 +101,65 @@ async function cloneRemoteAndCheckout(from, to, branch) {
 }
 
 async function cloneLocalAndCheckout(from, to, branch) {
-    debug(`local cloning ${from} into ${to}`);
-    await Git().clone(from, to, { local: true });
+    const gitRoot = await getGitRoot(from);
 
-    debug(`checking out '${branch}'...`);
-    await Git(to).checkout(branch);
+    debug(`local cloning ${gitRoot} into ${to}`);
+    await Git().clone(gitRoot, to, { '--local'  : true });
+
+    if (branch) {
+        debug(`checking out '${branch}'...`);
+        await Git(to).checkout(branch);
+    }
 }
 
 async function gitCheckoutBeforeAndAfter(gitDir, beforeBranch, afterBranch) {
+    debug(`retrieving before branch: ${beforeBranch}`);
     beforeBranch = await getBeforeBranch(gitDir, beforeBranch);
+    debug(`retrieving after branch: ${afterBranch}`);
     afterBranch = await getAfterBranch(gitDir, afterBranch);
+    if (beforeBranch === afterBranch) {
+        return {
+            before: {
+                branch: beforeBranch
+            },
+            after: {
+                branch: afterBranch,
+            }
+        };
+    }
 
     debug(`cloning branches ${beforeBranch} (before) and ${afterBranch} (after)...`);
 
     const tempDir = tmp.dirSync({unsafeCleanup: true}).name;
     debug(`temporary directory: ${tempDir}`);
 
-    const beforeDir = path.join(tempDir, "before");
-    await cloneRemoteAndCheckout(gitDir, beforeDir, beforeBranch);
+    // before checkout --------------------------------------------------------------
 
-    const afterDir = path.join(tempDir, "after");
-    if (process.env.CI || await hasRemoteTrackingBranch(afterDir)) {
-        await cloneRemoteAndCheckout(gitDir, afterDir, afterBranch);
+    const beforeDir = path.join(tempDir, "before");
 
+    // we can use the faster local clone only if the "branch" is present locally
+    if (await hasBranch(gitDir, beforeBranch)) {
+        debug(`[before] using local cloning because existing checkout already has before branch '${beforeBranch}'`);
+        await cloneLocalAndCheckout(gitDir, beforeDir, beforeBranch);
     } else {
-        // if sizewatcher is run locally inside checkout
-        await cloneLocalAndCheckout(gitDir, afterDir, afterBranch);
+        debug(`[before] using remote cloning, as existing checkout does not have before branch '${beforeBranch}'`);
+        // ...otherwise need to do a full remote clone
+        await cloneRemoteAndCheckout(gitDir, beforeDir, beforeBranch);
+    }
+
+    // after checkout --------------------------------------------------------------
 
+    const afterDir = path.join(tempDir, "after");
+
+    debug(`[after] using local cloning`);
+    await cloneLocalAndCheckout(gitDir, afterDir);
+    try {
         // need to ensure before branch is available under local name
         await Git(afterDir).branch([beforeBranch, "-t", `origin/${beforeBranch}`]);
+    } catch (e) {
+        debug("ignoring error", e);
     }
+    debug(`[after] current branch: ${await currentBranch(afterDir)}`);
 
     debug("folders ready");
 

package/lib/comparators/custom.js

@@ -19,41 +19,97 @@ const du = require("du");
 const path = require("path");
 const fs = require("fs");
 const pb = require('pretty-bytes');
+const { spawn } = require('child_process');
+const glob = require("glob");
 
-module.exports = {
+async function spawnProcess(command, args, options) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, options);
 
-    getPath: function() {
-        return this.config && this.config.path;
-    },
+        child.on("error", (err) => reject(err));
+        child.on("exit", (code, signal) => {
+            if (code !== 0) {
+                let cmdString = command;
+                if (args.length > 0) {
+                    cmdString += ` ${args.join(" ")}`;
+                }
+                const err = new Error(`\`${cmdString}\` failed with exit code ${code}${signal ? `(received signal: ${signal})` : ""}`);
+                err.exitCode = code;
+                err.signal = signal;
+                reject(err);
+            }
+            resolve();
+        });
+    });
+}
+
+async function runScript(script, path) {
+    await spawnProcess(script, [], {
+        shell: true,
+        cwd: path,
+        // log / pass-through all output
+        stdio: "inherit"
+    });
+}
+
+async function measure(baseDir, globPath, fileListing) {
+    let total = 0;
+    const files = glob.sync(path.join(baseDir, globPath));
+    for (const file of files) {
+        if (fs.existsSync(file)) {
+            const fileSize = await du(file);
+            total += fileSize;
+
+            if (fileListing) {
+                fileListing.push(`${pb(fileSize)} ${path.relative(baseDir, file)}`);
+            }
+        }
+    }
+    return total;
+}
+
+module.exports = {
 
     shouldRun: async function(beforeDir, afterDir) {
-        const p = this.config && this.config.path;
-        if (!p) {
+        if (!this.config.path || typeof this.config.path !== "string") {
             return false;
         }
-        if (path.isAbsolute(p)) {
-            console.error("Error: custom comparator path must be relative:", p);
+        // if it has a script, we have to run (the script might create the files)
+        if (typeof this.config.script === "string") {
+            return true;
+        }
+
+        if (this.config.path.startsWith("/")) {
+            console.error("Error: custom comparator path must be relative:", this.config.path);
             return false;
         }
-        return fs.existsSync(path.join(beforeDir, p)) ||
-               fs.existsSync(path.join(afterDir, p));
+        return glob.sync(path.join(beforeDir, this.config.path)).length > 0 ||
+                glob.sync(path.join(afterDir, this.config.path)).length > 0;
     },
 
     compare: async function(before, after) {
-        debug(`measuring custom ${this.getPath()} in ${before.dir}...`);
-        const beforePath = path.join(before.dir, this.getPath());
-        const beforeSize = fs.existsSync(beforePath) ? await du(beforePath) : 0;
+        if (this.config.script) {
+            debug(`running script in ${before.dir}: ${this.config.script}`);
+            await runScript(this.config.script, before.dir);
+
+            debug(`running script in ${after.dir}: ${this.config.script}`);
+            await runScript(this.config.script, after.dir);
+        }
+
+        const fileListing = [];
+
+        debug(`measuring ${this.config.path} in ${before.dir}...`);
+        const beforeSize = await measure(before.dir, this.config.path);
 
-        debug(`measuring custom ${this.getPath()} in ${after.dir}...`);
-        const afterPath = path.join(after.dir, this.getPath());
-        const afterSize = fs.existsSync(afterPath) ? await du(afterPath) : 0;
+        debug(`measuring ${this.config.path} in ${after.dir}...`);
+        const afterSize = await measure(after.dir, this.config.path, fileListing);
 
         return {
             name: this.config.name || this.config.path,
             beforeSize,
             afterSize,
             detailsLabel: "New size",
-            details: `${pb(afterSize)} ${this.config.path}`
+            details: fileListing.join("\n")
         };
     }
 };

package/lib/comparators/git.js

@@ -19,7 +19,7 @@ const du = require("du");
 const path = require("path");
 const fs = require("fs");
 const { execSync } = require("child_process");
-const Git = require("simple-git/promise");
+const Git = require("simple-git");
 
 async function getSize(dir) {
     debug(`git garbage collection of '${dir}'...`);
@@ -50,7 +50,7 @@ module.exports = {
     compare: async function(before, after) {
         const beforeSize = await getSize(before.dir);
         const afterSize = await getSize(after.dir);
-        const details = await largestCommits(after.dir, before.branch, after.branch);
+        const details = await largestCommits(after.dir, before.branch, after.sha);
 
         return {
             beforeSize,

package/lib/comparators/node_modules.js

@@ -20,34 +20,66 @@ const du = require("du");
 const path = require("path");
 const fs = require("fs");
 
+function isEmptyObject(obj) {
+    return Object.keys(obj).length === 0 && obj.constructor === Object;
+}
+
+function hasPackageJson(dir) {
+    return fs.existsSync(path.join(dir, "package.json"));
+}
+
 async function getSize(dir) {
+    if (!hasPackageJson(dir)) {
+        return 0;
+    }
     process.chdir(dir);
+
     debug(`installing node dependencies inside ${dir}...`);
     if (fs.existsSync("package-lock.json") || fs.existsSync("npm-shrinkwrap.json")) {
         execSync("npm ci");
     } else {
         execSync("npm install");
     }
-    debug(`calculating folder size of ${dir}/node_modules...`);
-    return du(path.join(dir, "node_modules"));
+
+    const nodeModules = path.join(dir, "node_modules");
+    if (fs.existsSync(nodeModules)) {
+        debug(`calculating folder size of ${nodeModules}...`);
+        return du(nodeModules);
+    } else {
+        return 0;
+    }
 }
 
 async function costOfModules(dir) {
+    if (!hasPackageJson(dir)) {
+        return "(no package.json)";
+    }
     process.chdir(dir);
-    debug(`running cost-of-modules...`);
-    const out = execSync("npx cost-of-modules --less --no-install").toString();
 
-    const PREFIX = "\nCalculating...\n\n\n";
-    if (out.startsWith(PREFIX)) {
-        return out.substring(PREFIX.length);
+    const pkgJsonPath = path.join(dir, "package.json");
+    const pkgJson = require(pkgJsonPath);
+    if (!pkgJson.dependencies || isEmptyObject(pkgJson.dependencies)) {
+        return "(no production dependencies)";
     }
-    return out;
+
+    debug(`running cost-of-modules...`);
+    try {
+        const out = execSync("npx cost-of-modules --less --no-install").toString();
+        const PREFIX = "\nCalculating...\n\n\n";
+        if (out.startsWith(PREFIX)) {
+            return out.substring(PREFIX.length);
+        }
+        return out;
+    } catch (e) {
+        throw new Error(`cost-of-modules failed with: ${e.stdout ? e.stdout.toString() : ""} ${e.stdout ? e.stderr.toString() : ""}`);
+    }
+
 }
 
 module.exports = {
 
     shouldRun: async function(beforeDir, afterDir) {
-        return fs.existsSync(path.join(afterDir, "package.json"));
+        return hasPackageJson(beforeDir) || hasPackageJson(afterDir);
     },
 
     compare: async function(before, after) {
@@ -58,7 +90,7 @@ module.exports = {
         return {
             beforeSize,
             afterSize,
-            detailsLabel: "Largest node modules",
+            detailsLabel: "Largest production node modules",
             details
         };
     }

package/lib/comparators/npm_package.js

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+'use strict';
+
+// comparators/npm_package.js - compares npm package (tarball) size
+
+const debug = require("debug")("sizewatcher:node_modules");
+const util = require('util');
+const exec = util.promisify(require('child_process').exec);
+const path = require("path");
+const fs = require("fs");
+const xbytes = require("xbytes");
+
+const PACKSIZE_REGEX = /package size: (.*)/;
+
+async function getSize(dir) {
+    if (!fs.existsSync(path.join(dir, "package.json"))) {
+        return {
+            size: 0
+        };
+    }
+
+    debug(`running npm publish --dry-run inside ${dir}...`);
+    let { stderr } = await exec("npm publish --dry-run", { cwd: dir });
+
+    stderr = stderr.replace(/npm notice /g, "");
+
+    const found = stderr.match(PACKSIZE_REGEX);
+    const size = found ? xbytes.parseSize(found[1].trim()) : 0;
+
+    return {
+        size,
+        output: stderr
+    };
+}
+
+module.exports = {
+
+    shouldRun: async function(beforeDir, afterDir) {
+        const pkgJsonPath = path.join(afterDir, "package.json");
+        if (!fs.existsSync(pkgJsonPath)) {
+            return false;
+        }
+
+        const pkgJson = require(pkgJsonPath);
+        if (pkgJson.private || !pkgJson.version) {
+            debug("skpping npm_package: private package or no version in package.json");
+            return false;
+        }
+        return true;
+    },
+
+    compare: async function(before, after) {
+        const beforeResult = await getSize(before.dir);
+        const afterResult = await getSize(after.dir);
+
+        return {
+            beforeSize: beforeResult.size,
+            afterSize: afterResult.size,
+            detailsLabel: "Package contents",
+            details: afterResult.output
+        };
+    }
+};

package/lib/compare.js

@@ -18,18 +18,28 @@ const debug = require("debug")("sizewatcher");
 const config = require("./config").get();
 const COMPARATORS = require('require-dir')("./comparators");
 const xbytes = require('xbytes');
+const path = require("path");
 
 async function runComparator(comparator, before, after, deltas) {
-    if (await comparator.shouldRun(before.dir, after.dir)) {
-        console.log(`- ${comparator.name}`);
-        const delta = await comparator.compare(before, after);
-        // force same name for consistency with config
-        delta.name = comparator.name;
-        delta.config = comparator.config;
-
-        deltas.push(delta);
-    } else {
-        debug(`skipping '${comparator.name}' because it detected it should not run`);
+    try {
+        if (await comparator.shouldRun(before.dir, after.dir)) {
+            console.log(`- ${comparator.name}`);
+            const delta = await comparator.compare(before, after);
+            // force same name for consistency with config
+            delta.name = comparator.name;
+            delta.config = comparator.config;
+
+            deltas.push(delta);
+        } else {
+            debug(`skipping '${comparator.name}' because it detected it should not run`);
+        }
+    } catch (e) {
+        console.error(`comparator ${comparator.name} failed:`, e);
+
+        deltas.push({
+            name: comparator.name,
+            error: e
+        });
     }
 }
 
@@ -63,10 +73,30 @@ async function compare(before, after) {
                 debug(`skipping '${name}' because disabled in config`);
                 continue;
             }
-            comparator.name = name;
-            comparator.config = comparatorConfig || {};
-
-            await runComparator(comparator, before, after, deltas);
+            let dirs = ["."];
+            if (comparatorConfig && comparatorConfig.dir) {
+                if (Array.isArray(comparatorConfig.dir)) {
+                    dirs = comparatorConfig.dir;
+                } else {
+                    dirs = [comparatorConfig.dir];
+                }
+            }
+            for (const dir of dirs) {
+                if (dir !== ".") {
+                    comparator.name = `${name} [${dir}]`;
+                } else {
+                    comparator.name = name;
+                }
+                comparator.config = comparatorConfig || {};
+
+                await runComparator(comparator, {
+                    ...before,
+                    dir: path.join(before.dir, dir)
+                }, {
+                    ...after,
+                    dir: path.join(after.dir, dir)
+                }, deltas);
+            }
         }
     }
 
@@ -101,17 +131,32 @@ function process(deltas) {
         cheers: 0,
         ok: 0,
         warn: 0,
-        fail: 0
+        fail: 0,
+        error: 0
     };
 
     for (const d of deltas) {
+        debug("processing delta:", d);
+        if (d.error) {
+            summary.error++;
+            continue;
+        }
         // merge limit config, comparator-specific one wins over global
         const limits = {
             ...config.limits,
             ...d.config.limits
         };
 
-        const increase = (d.afterSize - d.beforeSize) / d.beforeSize * 100;
+        let increase;
+        if (d.beforeSize <= 0 && d.afterSize <= 0) {
+            increase = 0;
+        } else if (d.afterSize <= 0) {
+            increase = -100;
+        } else if (d.beforeSize <= 0) {
+            increase = 100;
+        } else {
+            increase = (d.afterSize - d.beforeSize) / d.beforeSize * 100;
+        }
         d.increase = increase.toFixed(1);
 
         if (exceeds(d.afterSize, increase, limits.fail)) {
@@ -134,7 +179,9 @@ function process(deltas) {
     }
 
     deltas.summary = "ok";
-    if (summary.fail >= 1) {
+    if (summary.error >= 1) {
+        deltas.summary = "error";
+    } else if (summary.fail >= 1) {
         deltas.summary = "fail";
     } else if (summary.warn >= 1) {
         deltas.summary = "warn";

package/lib/config.js

@@ -22,8 +22,8 @@ const CONFIG_FILE = ".sizewatcher.yml";
 
 const DEFAULT_CONFIG = {
     limits: {
-        fail: "50%",
-        warn: "10%",
+        fail: "100%",
+        warn: "30%",
         ok: "-10%"
     },
     report: {
@@ -39,7 +39,7 @@ function load() {
 
     if (fs.existsSync(CONFIG_FILE)) {
         const data = fs.readFileSync(CONFIG_FILE, "utf8");
-        const loadedConfig = yaml.safeLoad(data);
+        const loadedConfig = yaml.safeLoad(data) || {};
 
         config = deepmerge(DEFAULT_CONFIG, loadedConfig);
 

package/lib/render.js

@@ -21,9 +21,20 @@ const ICONS = {
     cheers: "🎉",
     ok: "✅",
     warn: "⚠️",
-    fail: "❌"
+    fail: "❌",
+    error: "🚨"
 };
 
+const SUMMARY = {
+    cheers: "congratulates on the size improvement 📉:",
+    ok: "found no problematic size increases.",
+    warn: "detected a size increase 📈:",
+    fail: "detected a problematic size increase 📈:",
+    error: "had a measurement error:"
+};
+
+const EXPANDED_CASES = ["cheers", "warn", "fail", "error"];
+
 function indentEachLine(string, indent="  ") {
     return string.replace(/^(?!\s*$)/gm, indent);
 }
@@ -34,11 +45,15 @@ function renderAsText(deltas) {
     text += `  '${deltas.before.branch}' => '${deltas.after.branch}' (sha ${deltas.after.sha})\n\n`;
 
     for (const d of deltas) {
-        text += `+ ${ICONS[d.result]}  ${d.name}: ${d.increase}% (${pb(d.beforeSize)} => ${pb(d.afterSize)})\n\n`;
+        if (d.error) {
+            text += `+ ${ICONS.error} ${d.name}: measurement error: ${d.error.message || d.error}\n`;
+        } else {
+            text += `+ ${ICONS[d.result]}  ${d.name}: ${d.increase}% (${pb(d.beforeSize)} => ${pb(d.afterSize)})\n\n`;
 
-        if (d.details) {
-            text += `  ${d.detailsLabel}:\n\n`;
-            text += indentEachLine(d.details.trim()) + "\n";
+            if (d.details) {
+                text += `  ${d.detailsLabel}:\n\n`;
+                text += indentEachLine(d.details.trim()) + "\n";
+            }
         }
         text += `\n`;
     }
@@ -47,12 +62,20 @@ function renderAsText(deltas) {
 }
 
 function renderAsMarkdown(deltas) {
-    let markdown = `📈 [Sizewatcher](https://github.com/adobe/sizewatcher) measured these changes:\n\n`;
+    const summaryState = deltas.summary || "ok";
+    const detailState = EXPANDED_CASES.includes(summaryState) ? "open" : "";
+
+    let markdown = `<details ${detailState}><summary>${ICONS[summaryState]} <a href="https://github.com/adobe/sizewatcher">Sizewatcher</a> ${SUMMARY[summaryState]}</summary>\n`;
+    markdown += `<p><blockquote>\n\n`;
 
     for (const d of deltas) {
         let change;
 
-        if (d.increase >= 0.1) {
+        if (d.error) {
+            d.result = "error";
+            change = `measurement error: ${d.error.message || d.error}`;
+
+        } else if (d.increase >= 0.1) {
             change = `<b>+${d.increase}%</b> (${pb(d.beforeSize)} => ${pb(d.afterSize)})`;
 
         } else if (d.increase <= -0.1) {
@@ -63,22 +86,30 @@ function renderAsMarkdown(deltas) {
 
         }
 
-        markdown += `<details>\n<summary>${ICONS[d.result]} <code>${d.name}</code> ${change}</summary>\n`;
         if (d.details) {
-            markdown += `<br>\n\n${d.detailsLabel}:\n\`\`\`\n${d.details.trim()}\n\`\`\`\n`;
+            markdown += `<details><summary>`;
+        } else {
+            markdown += "&nbsp;&nbsp;&nbsp;";
+        }
+        markdown += `${ICONS[d.result]} <code>${d.name}</code> ${change}`;
+        if (d.details) {
+            markdown += `</summary><br>${d.detailsLabel}:<pre>${d.details.trim().replace(/\n/g, "<br>")}</pre></details>`;
         }
 
-        markdown += `</details>\n\n`;
+        markdown += `\n\n`;
     }
 
-    markdown += `<details>\n<summary>Notes</summary>\n<br>\n\n`;
+    markdown += `<details><summary>Notes</summary><br>\n\n`;
     markdown += `- PR branch: \`${deltas.after.branch}\` @ ${deltas.after.sha}\n`;
     markdown += `- Base branch: \`${deltas.before.branch}\`\n`;
     markdown += `- Sizewatcher v${require('../package.json').version}\n`;
-    markdown += `- Configuration\n`;
-    markdown += `<pre>\n${config.asYaml()}</pre>`;
+    markdown += `- Effective Configuration:\n`;
+    markdown += `\n\`\`\`yaml\n${config.asYaml()}\`\`\`\n`;
     markdown += `</details>\n\n`;
 
+    markdown += `</blockquote></p>\n`;
+    markdown += `</details>\n`;
+
     return markdown;
 }
 

package/lib/sizewatcher.js

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+'use strict';
+
+// main cli entry point
+
+const debug = require("debug")("sizewatcher");
+const gitCheckoutBeforeAndAfter = require("./checkout");
+const compare = require("./compare");
+const report = require("./report");
+const Git = require("simple-git");
+
+function printUsage() {
+    console.error(`Usage: sizewatcher [<options>] [<before> [<after>]]`);
+    console.error();
+    console.error("Arguments:");
+    console.error("  <before>   Before branch/commit for comparison. Defaults to default branch or main/master.");
+    console.error("  <after>    After branch/commit for comparison. Defaults to current branch.");
+    console.error();
+    console.error("Options:");
+    console.error("  -h     Show help");
+}
+
+async function sizewatcher(argv) {
+    try {
+        if (!argv) argv = [];
+
+        // yes, this should probably use a framework like oclif or yargs.
+        // but cli arguments are very limited now and so manual handling is enough
+        if (argv[0] === "-h") {
+            printUsage();
+            return process.exit(1);
+        }
+
+        debug(`Running inside ${process.cwd()}`);
+
+        if (!await Git().checkIsRepo()) {
+            throw new Error(`Not inside a git checkout: ${process.cwd()}`);
+        }
+
+        console.log(`Checking out git branches...`);
+        const { before, after } = await gitCheckoutBeforeAndAfter(process.cwd(), argv[0], argv[1]);
+
+        if (before.branch === after.branch) {
+            console.log(`Branches are identical, nothing to compare (${before.branch}=${after.branch}). Compare selected branches using 'sizewatcher <before> <after>'.`);
+            return process.exit();
+        }
+
+        console.log(`Comparing changes from '${before.branch}' to '${after.branch}'\n`);
+
+        const deltas = await compare(before, after);
+
+        await report(deltas);
+
+        console.log("Done. Cleaning up...");
+
+    } catch (e) {
+        debug(e);
+        console.error("Error:", e.message || e);
+        return process.exit(1);
+    }
+}
+
+module.exports = sizewatcher;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/sizewatcher",
-  "version": "1.0.0",
+  "version": "1.2.1",
   "description": "Warns if your pull requests introduce large size increases.",
   "main": "index.js",
   "bin": {
@@ -30,17 +30,19 @@
     "eslint": "^7.1.0",
     "mocha": "^7.2.0",
     "mock-fs": "^4.13.0",
-    "nyc": "^15.1.0"
+    "nyc": "^15.1.0",
+    "supports-color": "^8.1.1"
   },
   "dependencies": {
     "@octokit/rest": "^18.0.3",
     "debug": "^4.1.1",
     "deepmerge": "^4.2.2",
     "du": "^1.0.0",
+    "glob": "^7.1.6",
     "js-yaml": "^3.14.0",
     "pretty-bytes": "^5.3.0",
     "require-dir": "^1.2.0",
-    "simple-git": "^2.5.0",
+    "simple-git": "^3.7.1",
     "tmp": "^0.2.1",
     "xbytes": "^1.6.2"
   }