@vernikr/size-report 2.8.7 → 2.8.9

package/README.md

@@ -1,9 +1,9 @@
 # @vernikr/size-report
 
-A tool that watches how much code and documentation a project carries, commit by commit. Every
-change is shown in three measures at once — as written (`raw`), minified (`min`) and in tokens for a
-language model (`tok`) — so a person can see where a project is swelling and an agent can see what a
-change weighs in its own context. It forbids nothing and blocks nothing: it only shows.
+Watches how much code and documentation a project carries, commit by commit. Every file is measured
+as written (`raw`), minified (`min`) and in tokens for a language model (`tok`), so a person sees
+where a project swells and an agent sees what a change weighs in its own context. It forbids nothing
+and blocks nothing: it only shows.
 
 The report is a single self-contained page (`docs/size-report.html`) — no server, no network — and it
 refreshes itself after every commit. A project needs no settings to start: with no config file the
@@ -30,16 +30,12 @@ pnpm exec size install-hook       # rebuild the report after every commit and me
 
 ## Where the rest is
 
-- [`docs/architecture.md`](docs/architecture.md) — how the tool is put together: the engine, the report
-  page, the checks and the promises they hold, the gate against bloat, the traps of the engine and what
-  is not here yet.
-- [`docs/wiring.md`](docs/wiring.md) — wiring the tool into a project step by step, the settings and its
-  surface for an agent.
-- [`docs/files.md`](docs/files.md) — what is in the repository: the role of every file and module.
-- [`docs/archive/README_old.md`](docs/archive/README_old.md) — the release notes the main page used to
-  carry.
-- [`AGENTS.md`](AGENTS.md) — how to work inside this repository: what to run, what to do when a sensor
-  is red.
+- [`docs/architecture.md`](docs/architecture.md) — how the tool is built, the checks and the gate
+  against bloat.
+- [`docs/wiring.md`](docs/wiring.md) — wiring it into a project, the settings, the surface for an
+  agent.
+- [`docs/files.md`](docs/files.md) — what is in this repository.
+- [`AGENTS.md`](AGENTS.md) — how to work inside this repository.
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vernikr/size-report",
-  "version": "2.8.7",
+  "version": "2.8.9",
   "author": "vernikr",
   "repository": {
     "type": "git",
@@ -65,7 +65,7 @@
     "report"
   ],
   "devDependencies": {
-    "@vernikr/size-report": "2.8.6",
+    "@vernikr/size-report": "2.8.8",
     "c8": "10",
     "dependency-cruiser": "17",
     "eslint": "^9.18.0",

package/src/config.js

@@ -1,7 +1,6 @@
 import fs from 'fs';
 import path from 'path';
-import { execFileSync } from 'child_process';
-import { MAX_BUF, gitArgv, gitEnv } from './git.js';
+import { gitRead } from './git.js';
 import { advicePath, cliCommand, invocation, refuseCause } from './refusal.js';
 import { LOCALES } from './locales.js';
 import { METRICS, MINIFY_ENGINES } from './metrics.js';
@@ -51,9 +50,7 @@ export function argValue(args, name) {
 
 export function gitRoot() {
   try {
-    return execFileSync('git', gitArgv(['rev-parse', '--show-toplevel']), {
-      encoding: 'utf8', maxBuffer: MAX_BUF, env: gitEnv()
-    }).trim();
+    return gitRead(process.cwd(), ['rev-parse', '--show-toplevel']).trim();
   } catch (e) {
     // Two dead ends with different fixes — "git did not start" and "there is no repository here" —
     // are told apart by what git itself said rather than by a guess: ENOENT means the program was not

package/src/git.js

@@ -36,10 +36,21 @@ export function gitEnv() {
   return Object.assign({}, process.env, { LC_ALL: 'C', LANG: 'C' });
 }
 
+/* How git is started here: the options that make a read the same on any machine, written once. A caller
+ * adds what only it needs — `input` for a batch, `encoding: undefined` where the answer is the bytes of a
+ * blob rather than text, an environment on top of the boundary's own (the hook builds its commit in a
+ * separate index with it). */
+function gitOptions(root, extra) {
+  return Object.assign({ cwd: root, encoding: 'utf8', maxBuffer: MAX_BUF, env: gitEnv() }, extra || {});
+}
+
+/* A read: stdout as text, and an exception where git did not answer. */
+export function gitRead(root, args, extra) {
+  return execFileSync('git', gitArgv(args), gitOptions(root, extra));
+}
+
 export function git(root, args) {
-  return execFileSync('git', gitArgv(args), {
-    cwd: root, encoding: 'utf8', maxBuffer: MAX_BUF, env: gitEnv()
-  });
+  return gitRead(root, args);
 }
 
 /* The same read, but with the exit code: where a non-zero code is an expected answer rather than
@@ -48,10 +59,7 @@ export function git(root, args) {
  * environment — the hook builds the report commit in a separate index with it, leaving the real
  * one untouched (`src/hook.js`). */
 export function gitTry(root, args, env) {
-  const res = spawnSync('git', gitArgv(args), {
-    cwd: root, encoding: 'utf8', maxBuffer: MAX_BUF,
-    env: Object.assign(gitEnv(), env || {})
-  });
+  const res = spawnSync('git', gitArgv(args), gitOptions(root, { env: Object.assign(gitEnv(), env || {}) }));
   return { status: res.status, stdout: res.stdout || '', stderr: res.stderr || '' };
 }
 
@@ -66,15 +74,14 @@ export function gitTry(root, args, env) {
 const BLOB_CHUNK = 1000; // specs per batch: it bounds both stdin and memory
 
 function catFileCheck(root, specs) {
-  const out = execFileSync('git', gitArgv(['cat-file', '--batch-check=%(objectname) %(objecttype) %(objectsize)']), {
-    cwd: root, encoding: 'utf8', input: specs.join('\n') + '\n', maxBuffer: MAX_BUF, env: gitEnv()
-  });
+  const out = gitRead(root, ['cat-file', '--batch-check=%(objectname) %(objecttype) %(objectsize)'],
+    { input: specs.join('\n') + '\n' });
   return out.split('\n');
 }
 
 function catFileBatch(root, shas) {
-  const buf = execFileSync('git', gitArgv(['cat-file', '--batch']), {
-    cwd: root, input: shas.join('\n') + '\n', maxBuffer: MAX_BUF, env: gitEnv()
+  const buf = gitRead(root, ['cat-file', '--batch'], {
+    input: shas.join('\n') + '\n', encoding: undefined
   });
   const out = new Map();
   let i = 0;
@@ -124,9 +131,7 @@ export function readBlobs(root, specs, needText) {
  * the output is split by NUL (`-z`), or paths with spaces would have to be unquoted. */
 export function headTree(root) {
   const out = new Map();
-  const tree = execFileSync('git', gitArgv(['ls-tree', '-r', '-z', 'HEAD']), {
-    cwd: root, encoding: 'utf8', maxBuffer: MAX_BUF, env: gitEnv()
-  });
+  const tree = gitRead(root, ['ls-tree', '-r', '-z', 'HEAD']);
   tree.split('\u0000').forEach((rec) => {
     const tab = rec.indexOf('\t');
     if (tab < 0) return;
@@ -142,9 +147,8 @@ export function headTree(root) {
  * the answers are positional, as with `cat-file`. */
 export function diskHashes(root, paths) {
   const out = new Map();
-  const lines = execFileSync('git', gitArgv(['hash-object', '--stdin-paths']), {
-    cwd: root, encoding: 'utf8', input: paths.join('\n') + '\n', maxBuffer: MAX_BUF, env: gitEnv()
-  }).split('\n');
+  const lines = gitRead(root, ['hash-object', '--stdin-paths'],
+    { input: paths.join('\n') + '\n' }).split('\n');
   paths.forEach((p, i) => { out.set(p, lines[i] === undefined ? '' : lines[i].trim()); });
   return out;
 }
@@ -155,9 +159,7 @@ export function diskHashes(root, paths) {
  * while "cleaning" would turn it back into LF — git warns about such files and puts exactly this
  * on disk. */
 export function diskForm(root, rev, p) {
-  return execFileSync('git', gitArgv(['cat-file', '--filters', rev + ':' + p]), {
-    cwd: root, maxBuffer: MAX_BUF, env: gitEnv()
-  });
+  return gitRead(root, ['cat-file', '--filters', rev + ':' + p], { encoding: undefined });
 }
 
 // The content of a file in a revision, or null when the file is not there.

package/src/page/table.js

@@ -332,9 +332,11 @@ export function appWindow(cache, redraw) {
     return;
   }
   appHead(cache, span);
-  [...cache.rows.keys()].forEach((r) => {
-    if (r >= span.r0 && r <= span.r1) { appCells(cache.rows.get(r), cache, span); return; }
-    cache.rows.get(r).el.remove();
+  /* Walking the map itself rather than a copy of its keys: a step down the table does not allocate,
+   * and the entry the window keeps is taken where it is rather than looked up a second time. */
+  cache.rows.forEach((entry, r) => {
+    if (r >= span.r0 && r <= span.r1) { appCells(entry, cache, span); return; }
+    entry.el.remove();
     cache.rows.delete(r);
   });
   for (let r = span.r0; r <= span.r1; r++) {

package/src/project.js

@@ -1,7 +1,6 @@
 import fs from 'fs';
 import path from 'path';
-import { execFileSync } from 'child_process';
-import { MAX_BUF, git, gitArgv, gitEnv, gitTry, readHistory } from './git.js';
+import { git, gitRead, gitTry, readHistory } from './git.js';
 import { cliCommand, invocation } from './refusal.js';
 
 /* Settings derived from the project itself: what to measure, where the journal is, where to write,
@@ -41,21 +40,24 @@ const JOURNALS = ['WORKLOG.md', 'CHANGELOG.md', 'CHANGES.md', 'HISTORY.md'];
 const MAX_BYTES = 512 * 1024;
 
 /* The index gives paths and sizes: `ls-files -s` yields the objects, and their sizes are asked for in
- * one batch (`cat-file --batch-check`) rather than by reading the content. */
+ * one batch (`cat-file --batch-check`) rather than by reading the content. One call per run: the tree
+ * is asked for once and the answer is handed to whoever needs it (`allPaths`, `projectConfig`). */
 function indexFiles(root) {
   const listed = git(root, ['ls-files', '-s']).split('\n').filter((l) => l !== '');
   const sizes = new Map();
   const shas = listed.map((l) => l.split(/\s+/)[1]);
   if (shas.length > 0) {
-    const checked = execFileSync('git', gitArgv(['cat-file', '--batch-check=%(objectname)\t%(objectsize)']), {
-      cwd: root, encoding: 'utf8', input: shas.join('\n') + '\n', maxBuffer: MAX_BUF, env: gitEnv()
-    });
+    const checked = gitRead(root, ['cat-file', '--batch-check=%(objectname)\t%(objectsize)'],
+      { input: shas.join('\n') + '\n' });
     checked.split('\n').forEach((l) => {
       const [sha, size] = l.split('\t');
       sizes.set(sha, Number(size));
     });
   }
-  return listed.map((line) => ({ p: line.split('\t')[1], size: sizes.get(line.split(/\s+/)[1]) || 0 }));
+  return listed.map((line) => {
+    const [meta, p] = line.split('\t');
+    return { p: p, size: sizes.get(meta.split(' ')[1]) || 0 };
+  });
 }
 
 /* The history is the union of the paths of every commit, read the same way coverage reads it
@@ -76,9 +78,10 @@ function historyPaths(root) {
   return seen;
 }
 
-// The tree and the history in one list: everything the history touched may become a column.
-function allPaths(root) {
-  const files = indexFiles(root);
+// The tree and the history in one list: everything the history touched may become a column. The index
+// comes from outside rather than being read here, so that one run asks git for it once.
+function allPaths(root, index) {
+  const files = index.slice();
   const known = new Set(files.map((f) => f.p));
   historyPaths(root).forEach((p) => {
     if (!known.has(p)) files.push({ p: p, size: 0 });
@@ -206,11 +209,12 @@ function columnsOf(files, journal) {
 export function projectConfig(root) {
   const output = outputOf();
   const journal = journalOf(root);
-  const files = allPaths(root);
+  const index = indexFiles(root);
   /* Only what git tracks becomes a column: a file absent at HEAD has nothing to measure (it would be
    * empty in every row of the report). A path living only in the history is therefore an exception
    * rather than a column, while the list of paths stays complete either way. */
-  const tracked = new Set(indexFiles(root).map((f) => f.p));
+  const tracked = new Set(index.map((f) => f.p));
+  const files = allPaths(root, index);
   const readable = files.filter((f) => tracked.has(f.p) && !generated(f.p, output) && f.size <= MAX_BYTES);
   const columns = columnsOf(readable, journal);
   const taken = new Set(columns.reduce((all, c) => all.concat(c.paths), []));
@@ -272,7 +276,7 @@ export function projectTree(root, output, measured) {
  * (`test/api.test.js` holds the list of names), and the shape of the answer is the same — columns,
  * the extensions the project knows, and how many paths there are in total. */
 export function sniffColumns(root) {
-  const files = allPaths(root);
+  const files = allPaths(root, indexFiles(root));
   const exts = [...new Set(files.map((f) => path.extname(f.p).toLowerCase()))]
     .filter((e) => KNOWN_EXTS.indexOf(e) >= 0).sort();
   return { columns: projectConfig(root).columns, exts: exts, total: files.length };