reslop 0.2.6 → 0.3.0

package/lib/dashboard/tree.js

@@ -2,11 +2,10 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
+const { posixRel } = require('../common/files.js');
 
-const git = require('../git-worktree.js');
-const { runGitAsync } = git;
-const watch = require('../session/watch.js');
-const { UNKNOWN_PATH } = watch;
+const { runGit } = require('../git/worktree.js');
+const { UNKNOWN_PATH } = require('./watch.js');
 
 const ROOT_DIR = '.';
 const NO_EXT = '(none)';
@@ -15,11 +14,9 @@ const BINARY_PROBE = 8000;
 const CONCURRENCY = 32;
 const HEAT_MS = 4000;
 const RECENT_KEEP = 64;
-const SKIP_WALK = new Set(['.git', 'node_modules']);
+const SKIP_WALK = ['.git', 'node_modules'];
 const SKIP_PREFIX = ['.git/', 'node_modules/'];
 
-const slash = (rel) => `${rel}`.replaceAll('\\', '/');
-
 const folderOf = (rel) => {
   const at = rel.indexOf('/');
   return at < 0 ? ROOT_DIR : rel.slice(0, at);
@@ -79,16 +76,17 @@ const readEntry = async (root, rel, prev, at) => {
 
 const walkFiles = async (root, dir = '') => {
   const found = [];
-  let entries;
+  let entries = null;
   try {
-    entries = await fs.promises.readdir(path.join(root, dir), {
-      withFileTypes: true,
-    });
+    const dirPath = path.join(root, dir);
+    const types = { withFileTypes: true };
+    entries = await fs.promises.readdir(dirPath, types);
   } catch {
-    return found;
+    // unreadable directory
   }
+  if (!entries) return found;
   for (const entry of entries) {
-    if (SKIP_WALK.has(entry.name)) continue;
+    if (SKIP_WALK.includes(entry.name)) continue;
     const rel = dir ? `${dir}/${entry.name}` : entry.name;
     if (entry.isFile()) found.push(rel);
     if (!entry.isDirectory()) continue;
@@ -101,9 +99,9 @@ const walkFiles = async (root, dir = '') => {
 const listProject = async (root) => {
   const args = ['ls-files', '-z', '--cached', '--others', '--exclude-standard'];
   try {
-    const result = await runGitAsync(args, root);
+    const result = await runGit(args, root);
     if (result.status === 0) {
-      return result.stdout.split('\0').filter(Boolean).map(slash);
+      return result.stdout.split('\0').filter(Boolean).map(posixRel);
     }
   } catch {
     // not a git repository: walk the tree
@@ -115,9 +113,9 @@ const ignoredAmong = async (root, rels) => {
   if (!rels.length) return new Set();
   try {
     const args = ['check-ignore', '-z', '--', ...rels];
-    const result = await runGitAsync(args, root);
+    const result = await runGit(args, root);
     if (result.status !== 0 && result.status !== 1) return new Set();
-    return new Set(result.stdout.split('\0').filter(Boolean).map(slash));
+    return new Set(result.stdout.split('\0').filter(Boolean).map(posixRel));
   } catch {
     return new Set();
   }
@@ -132,8 +130,11 @@ const groupOf = (map, key) => {
   return group;
 };
 
-const bySize = (left, right) =>
-  right.bytes - left.bytes || left.key.localeCompare(right.key, 'en');
+const bySize = (left, right) => {
+  const byBytes = right.bytes - left.bytes;
+  const byKey = left.key.localeCompare(right.key, 'en');
+  return byBytes || byKey;
+};
 
 class FileIndex {
   constructor(root) {
@@ -209,7 +210,7 @@ class FileIndex {
   async touch(paths) {
     const rels = [];
     for (const item of paths) {
-      const rel = slash(item);
+      const rel = posixRel(item);
       if (rel === UNKNOWN_PATH) return this.rescan();
       if (SKIP_PREFIX.some((prefix) => rel.startsWith(prefix))) continue;
       rels.push(rel);
@@ -239,22 +240,18 @@ class FileIndex {
     const dirs = new Map();
     const exts = new Map();
     for (const entry of this.entries.values()) {
-      const groups = [
-        total,
-        groupOf(dirs, entry.dir),
-        groupOf(exts, entry.ext),
-      ];
+      const byDir = groupOf(dirs, entry.dir);
+      const byExt = groupOf(exts, entry.ext);
+      const groups = [total, byDir, byExt];
       for (const group of groups) {
         group.files += 1;
         group.bytes += entry.size;
         group.lines += entry.lines;
       }
     }
-    this.cached = {
-      total,
-      dirs: [...dirs.values()].sort(bySize),
-      exts: [...exts.values()].sort(bySize),
-    };
+    const dirList = [...dirs.values()].sort(bySize);
+    const extList = [...exts.values()].sort(bySize);
+    this.cached = { total, dirs: dirList, exts: extList };
     return this.cached;
   }
 

package/lib/{session → dashboard}/watch.js

@@ -3,14 +3,15 @@
 const fs = require('node:fs');
 const path = require('node:path');
 
-const runs = require('../runs.js');
+const runs = require('../runs/runs.js');
 const { isRunsRel } = runs;
+const { REVIEW_DIR, posixRel } = require('../common/files.js');
 
 const DEBOUNCE_MS = 200;
 const UNKNOWN_PATH = '.';
 const MODULES_STAMP = 'node_modules/.package-lock.json';
 
-const SKIP_DIRS = ['node_modules', '.review', 'coverage', 'dist', '.cache'];
+const SKIP_DIRS = ['node_modules', REVIEW_DIR, 'coverage', 'dist', '.cache'];
 
 const GIT_WATCH_NAMES = [
   'HEAD',
@@ -23,32 +24,31 @@ const GIT_WATCH_NAMES = [
   'rebase-apply',
 ];
 
-const canWatchRecursive = (
-  platform = process.platform,
-  version = process.versions.node,
-) => {
-  if (platform === 'win32' || platform === 'darwin') return true;
-  if (platform !== 'linux') return false;
-  const [major, minor] = `${version}`.split('.').map(Number);
+const canWatchRecursive = (platform, version) => {
+  const host = platform ?? process.platform;
+  const node = version ?? process.versions.node;
+  if (host === 'win32' || host === 'darwin') return true;
+  if (host !== 'linux') return false;
+  const [major, minor] = `${node}`.split('.').map(Number);
   return major > 19 || (major === 19 && minor >= 1);
 };
 
 const IGNORED_SUFFIXES = ['.lock', '~', '.swp', '.swo'];
 
-const ignoredName = (name) =>
-  IGNORED_SUFFIXES.some((suffix) => name.endsWith(suffix)) ||
-  name.startsWith('.#') ||
-  name === '.DS_Store';
+const ignoredName = (name) => {
+  const suffix = IGNORED_SUFFIXES.some((item) => name.endsWith(item));
+  const backup = name.startsWith('.#');
+  const store = name === '.DS_Store';
+  return suffix || backup || store;
+};
 
 const ignoredGitRel = ([, name = '', sub]) => {
   if (name === 'logs' && sub === 'HEAD') return false;
   return name !== '' && !GIT_WATCH_NAMES.includes(name);
 };
 
-const slashRel = (rel) => `${rel}`.replaceAll('\\', '/');
-
 const ignoredRel = (rel) => {
-  const norm = slashRel(rel);
+  const norm = posixRel(rel);
   if (!norm || norm === '.') return false;
   if (norm === MODULES_STAMP) return false;
   const parts = norm.split('/');
@@ -60,15 +60,16 @@ const ignoredRel = (rel) => {
 const skipDirName = (name) => name === '.git' || SKIP_DIRS.includes(name);
 
 const reviewMarkdown = (rel) => {
-  if (!rel.startsWith('.review/')) return false;
-  const rest = rel.slice('.review/'.length);
+  const prefix = `${REVIEW_DIR}/`;
+  if (!rel.startsWith(prefix)) return false;
+  const rest = rel.slice(prefix.length);
   if (!rest || rest.includes('/')) return false;
   return rest.endsWith('.md');
 };
 
 const isReviewDir = (root, dir) => {
-  const rel = slashRel(path.relative(root, dir));
-  return rel === '.review' || rel.startsWith('.review/');
+  const rel = posixRel(path.relative(root, dir));
+  return rel === REVIEW_DIR || rel.startsWith(`${REVIEW_DIR}/`);
 };
 
 const hasFile = (full) => {
@@ -84,13 +85,13 @@ const isBareReviewName = (root, dir, rel) => {
   if (!rel || rel.includes('/')) return false;
   const base = path.basename(rel);
   if (hasFile(path.join(dir, base))) return false;
-  return hasFile(path.join(root, '.review', base));
+  return hasFile(path.join(root, REVIEW_DIR, base));
 };
 
 const isReviewEvent = (root, dir, name) => {
   if (isReviewDir(root, dir)) return true;
   if (!name) return false;
-  const rel = slashRel(path.relative(root, path.join(dir, name)));
+  const rel = posixRel(path.relative(root, path.join(dir, name)));
   if (reviewMarkdown(rel)) return true;
   return isBareReviewName(root, dir, rel);
 };
@@ -98,7 +99,7 @@ const isReviewEvent = (root, dir, name) => {
 const isOwnDirEvent = (dir, name) => {
   if (!name) return false;
   const base = path.basename(dir);
-  const slash = slashRel(name);
+  const slash = posixRel(name);
   const bare = slash.startsWith('./') ? slash.slice(2) : slash;
   const trimmed = bare.endsWith('/') ? bare.slice(0, -1) : bare;
   if (trimmed === base) {
@@ -136,6 +137,7 @@ class DiskWatcher {
     this.onChange = options.onChange;
     this.onReview = options.onReview;
     this.onPaths = options.onPaths;
+    this.matchReview = options.matchReview ?? null;
     this.recursive = options.recursive ?? canWatchRecursive();
     this.watchers = [];
     this.watched = new Set();
@@ -152,8 +154,9 @@ class DiskWatcher {
     this.watchOne(gitDir);
     this.watchOne(path.join(gitDir, 'refs'));
     this.watchOne(path.join(gitDir, 'logs'));
+    this.watchOne(path.resolve(this.root, runs.logDir('.')));
     this.watchOne(path.resolve(this.root, runs.runsDir('.')));
-    this.watchOne(path.resolve(this.root, '.review'));
+    this.watchOne(path.resolve(this.root, REVIEW_DIR));
   }
 
   schedule(key, fire) {
@@ -210,9 +213,11 @@ class DiskWatcher {
   onEvent(dir, eventType, filename) {
     if (this.closed) return;
     const name = filename ? `${filename}` : '';
-    const rel = name
-      ? slashRel(path.relative(this.root, path.join(dir, name)))
-      : '';
+    let rel = '';
+    if (name) {
+      const full = path.join(dir, name);
+      rel = posixRel(path.relative(this.root, full));
+    }
     const wanted = this.files.has(rel);
     if (isRunsRel(rel)) {
       this.pending.add(rel);
@@ -227,6 +232,10 @@ class DiskWatcher {
       this.schedule('review', this.onReview);
       if (!wanted) return;
     }
+    if (rel && this.matchReview && this.matchReview(rel)) {
+      this.pending.add(rel);
+      return void this.schedule('paths', () => this.flushPaths());
+    }
     if (!name) return void this.scheduleUnnamed();
     if (!wanted && ignoredRel(rel)) return;
     if (isOwnDirEvent(dir, name)) return;
@@ -255,12 +264,13 @@ class DiskWatcher {
   watchTree(dir) {
     this.watchOne(dir, this.recursive);
     if (this.recursive) return;
-    let entries;
+    let entries = null;
     try {
       entries = fs.readdirSync(dir, { withFileTypes: true });
     } catch {
-      return;
+      // unreadable directory
     }
+    if (!entries) return;
     for (const entry of entries) {
       if (!entry.isDirectory() || skipDirName(entry.name)) continue;
       this.watchTree(path.join(dir, entry.name));
@@ -275,7 +285,7 @@ class DiskWatcher {
       return;
     }
     const name = path.basename(full);
-    if (name === '.review') this.watchOne(full);
+    if (name === REVIEW_DIR) this.watchOne(full);
     else if (!skipDirName(name)) this.watchTree(full);
   }
 
@@ -294,7 +304,7 @@ class DiskWatcher {
     for (const rel of rels) {
       if (!rel) continue;
       const full = path.resolve(this.root, rel);
-      this.files.add(slashRel(path.relative(this.root, full)));
+      this.files.add(posixRel(path.relative(this.root, full)));
       this.watchOne(path.dirname(full));
     }
   }

package/lib/dashboard/workspace.js

@@ -0,0 +1,151 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { REVIEW_DIR } = require('../common/files.js');
+const review = require('../review/review.js');
+const { listReviewNames, latestReviewName, loadReview, noteCounts } = review;
+const { countUntrackedAdded } = require('../git/worktree.js');
+const { gitText, countOf } = require('./git.js');
+const { runName } = require('./model.js');
+const { readRuns } = require('../runs/runs.js');
+
+const emptyDiff = () => ({
+  stagedAdded: 0,
+  unstagedAdded: 0,
+  stagedRemoved: 0,
+  unstagedRemoved: 0,
+});
+
+const isRepoDir = (dir) => {
+  try {
+    fs.accessSync(path.join(dir, '.git'));
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const listChildRepos = (dir) => {
+  let entries = null;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    // unreadable directory
+  }
+  if (!entries) return [];
+  const repos = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
+    const full = path.join(dir, entry.name);
+    if (!isRepoDir(full)) continue;
+    repos.push({ name: entry.name, dir: full });
+  }
+  repos.sort((left, right) => left.name.localeCompare(right.name, 'en'));
+  return repos;
+};
+
+const workspaceAt = (dir) => {
+  let stat = null;
+  try {
+    stat = fs.statSync(dir);
+  } catch {
+    // missing path
+  }
+  if (!stat) return null;
+  if (!stat.isDirectory() || isRepoDir(dir)) return null;
+  const repos = listChildRepos(dir);
+  if (!repos.length) return null;
+  return { root: path.resolve(dir), repos };
+};
+
+const workspaceFromArgs = (cwd, paths) => {
+  if (paths.length > 1) return null;
+  const dir = paths.length ? path.resolve(cwd, paths[0]) : cwd;
+  if (paths.length) {
+    try {
+      if (!fs.statSync(dir).isDirectory()) return null;
+    } catch {
+      return null;
+    }
+  }
+  return workspaceAt(dir);
+};
+
+const sumNumstat = (text) => {
+  let added = 0;
+  let removed = 0;
+  for (const line of `${text ?? ''}`.split('\n')) {
+    if (!line) continue;
+    const parts = line.split('\t');
+    const add = Number(parts[0]);
+    const del = Number(parts[1]);
+    if (Number.isFinite(add)) added += add;
+    if (Number.isFinite(del)) removed += del;
+  }
+  return { added, removed };
+};
+
+const readNumstat = async (dir, cached) => {
+  const stagedArgs = ['diff', '--cached', '--numstat'];
+  const openArgs = ['diff', '--numstat'];
+  const args = cached ? stagedArgs : openArgs;
+  return sumNumstat(await gitText(dir, args));
+};
+
+const readDiffStat = async (dir) => {
+  const [staged, open, untracked] = await Promise.all([
+    readNumstat(dir, true),
+    readNumstat(dir, false),
+    countUntrackedAdded(dir),
+  ]);
+  return {
+    stagedAdded: staged.added,
+    unstagedAdded: open.added + untracked,
+    stagedRemoved: staged.removed,
+    unstagedRemoved: open.removed,
+  };
+};
+
+const countCommits = async (dir) =>
+  countOf(await gitText(dir, ['rev-list', '--count', 'HEAD']));
+
+const taskStats = (dir) => {
+  const latest = latestReviewName(listReviewNames(dir));
+  if (!latest) return { done: 0, total: 0 };
+  try {
+    const file = path.join(dir, REVIEW_DIR, latest);
+    const counts = noteCounts(loadReview(file, []));
+    return { done: counts.tasksDone, total: counts.tasks };
+  } catch {
+    return { done: 0, total: 0 };
+  }
+};
+
+const pickRun = (dir) => {
+  const list = readRuns(dir);
+  const live = list.find((row) => row.status === 'running');
+  const record = live ?? list[0] ?? null;
+  if (!record) return null;
+  const progress = record.progress ?? {};
+  return {
+    name: runName(record),
+    status: record.status,
+    done: progress.done ?? 0,
+    failed: progress.failed ?? 0,
+    expected: progress.expected ?? 0,
+    result: record.result ?? null,
+  };
+};
+
+module.exports = {
+  emptyDiff,
+  workspaceAt,
+  workspaceFromArgs,
+  sumNumstat,
+  readDiffStat,
+  countCommits,
+  taskStats,
+  pickRun,
+};

package/lib/{deps.js → deps/deps.js}

@@ -2,18 +2,15 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const metautil = require('metautil');
-const { jsonParse, isHashObject } = metautil;
-const files = require('./files.js');
-const { itemPath } = files;
-const utilities = require('./utilities.js');
-const { asText } = utilities;
+const { jsonParse, isHashObject } = require('metautil');
+const { itemPath, REVIEW_DIR } = require('../common/files.js');
+const { asText, readText, readJson } = require('../common/utilities.js');
 const manifest = require('./manifest.js');
 const { MANIFEST, LOCKFILE, SECTION_KEYS, isObject } = manifest;
 const { depFileMeta, relOf, listFilePath, readSections } = manifest;
 const { lockEntries, findDeclared, applyWantedRange } = manifest;
 const { proposedLockVersion, proposedWanted } = manifest;
-const depDiff = require('./deps-diff.js');
+const depDiff = require('./diff.js');
 const { summarizeGroup, collectGroups, takeManifestItems } = depDiff;
 const { foldedDepNames, stripFoldedDepItem } = depDiff;
 const { makeDepItems, stubFileItem } = depDiff;
@@ -26,17 +23,9 @@ const SPEC_PATTERNS = [
   /import\(\s*['"]([^'"]+)['"]\s*\)/g,
 ];
 const SCRIPT_RUNNERS = ['npx', 'npm', 'node'];
-const SKIP_WALK = ['node_modules', '.git', '.review', 'coverage', 'dist'];
+const SKIP_WALK = ['node_modules', '.git', REVIEW_DIR, 'coverage', 'dist'];
 const SEVERITY_RANK = { critical: 4, high: 3, moderate: 2, low: 1, info: 0 };
 
-const readText = (file) => {
-  try {
-    return fs.readFileSync(file, 'utf8');
-  } catch {
-    return '';
-  }
-};
-
 const toPackageName = (spec) => {
   if (!spec || spec.startsWith('.') || spec.startsWith('/')) return '';
   if (spec.startsWith('node:')) return '';
@@ -102,12 +91,13 @@ const pkgExportsLibrary = (pkg) => {
 };
 
 const walkUsedNames = (used, dir) => {
-  let entries;
+  let entries = null;
   try {
     entries = fs.readdirSync(dir, { withFileTypes: true });
   } catch {
-    return;
+    // unreadable directory
   }
+  if (!entries) return;
   for (const entry of entries) {
     if (entry.isSymbolicLink()) continue;
     const full = path.join(dir, entry.name);
@@ -115,7 +105,7 @@ const walkUsedNames = (used, dir) => {
       const skip = SKIP_WALK.includes(entry.name) || entry.name.startsWith('.');
       if (!skip) walkUsedNames(used, full);
     } else if (entry.name === MANIFEST) {
-      collectUsedFromScripts(used, jsonParse(readText(full))?.scripts);
+      collectUsedFromScripts(used, readJson(full)?.scripts);
     } else if (SOURCE_EXT.includes(path.extname(entry.name))) {
       collectUsedFromText(used, readText(full));
     }
@@ -160,7 +150,7 @@ const collectExportEntries = (root, pkgDir, names) => {
 };
 
 const collectExportMeta = (root) => {
-  const pkg = jsonParse(readText(path.join(root, MANIFEST)));
+  const pkg = readJson(path.join(root, MANIFEST));
   const maps = readSections(pkg);
   const names = SECTION_KEYS.flatMap((key) => [...maps[key].keys()]);
   return collectExportEntries(root, '.', names);
@@ -288,8 +278,11 @@ const markChanges = (changes, report, kind) => {
 
 const depExports = (exportEntries, name) => exportEntries?.get(name) === true;
 
-const isAddedDep = (change) =>
-  change.action === 'added' && change.section !== 'resolved';
+const isAddedDep = (change) => {
+  const added = change.action === 'added';
+  const declared = change.section !== 'resolved';
+  return added && declared;
+};
 
 const unusedChangeNames = (changes, used) => {
   if (!used || !used.size) return [];
@@ -330,15 +323,10 @@ const unusedDeclaredChanges = (pkg, used, exportEntries) => {
     taken.add(name);
     const action = 'removed';
     const to = '';
-    changes.push({
-      name,
-      section,
-      action,
-      from,
-      to,
-      propose: true,
-      unused: true,
-    });
+    const propose = true;
+    const unused = true;
+    const change = { name, section, action, from, to, propose, unused };
+    changes.push(change);
   }
   return changes;
 };
@@ -438,28 +426,26 @@ const placeFolded = (items, { folded, synthetic, leftoverNames }) => {
   return spliceAtSlots(out, synthetic, slot);
 };
 
-const foldDepItems = (
-  items,
-  readSides = () => ({ oldText: '', newText: '' }),
-  usedNames = null,
-  audit = null,
-  outdated = null,
-  extra = {},
-) => {
+const foldDepItems = (items, readSides, usedNames, audit, outdated, extra) => {
+  const read = readSides ?? (() => ({ oldText: '', newText: '' }));
+  const used = usedNames ?? null;
+  const auditMap = audit ?? null;
+  const outdatedMap = outdated ?? null;
+  const options = extra ?? {};
   const groups = collectGroups(items);
   if (!groups.size) return items;
   const folded = new Set();
   const synthetic = new Map();
   const leftoverNames = new Map();
   for (const [key, group] of groups) {
-    const summary = summarizeGroup(group, readSides);
-    const unusedNames = unusedChangeNames(summary.changes, usedNames);
-    const exportEntries = loadExportEntries(unusedNames, extra, group.dir);
+    const summary = summarizeGroup(group, read);
+    const unusedNames = unusedChangeNames(summary.changes, used);
+    const exportEntries = loadExportEntries(unusedNames, options, group.dir);
     const { pkg } = summary;
     let changes = summary.changes;
-    changes = markUnusedChanges(changes, usedNames, pkg, exportEntries);
-    changes = markChanges(changes, audit, 'audit');
-    changes = markChanges(changes, outdated, 'outdated');
+    changes = markUnusedChanges(changes, used, pkg, exportEntries);
+    changes = markChanges(changes, auditMap, 'audit');
+    changes = markChanges(changes, outdatedMap, 'outdated');
     const next = { ...summary, changes };
     leftoverNames.set(key, foldedDepNames(changes));
     const taken = takeManifestItems(next);