reslop 0.2.7 → 0.3.1

package/lib/common/utilities.js

@@ -0,0 +1,112 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { split, jsonParse } = require('metautil');
+
+const parseVersion = (text) => {
+  const match = /^(\d+)\.(\d+)\.(\d+)/.exec(`${text ?? ''}`);
+  if (!match) return null;
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  const patch = Number(match[3]);
+  return { major, minor, patch };
+};
+
+const cmpVersion = (left, right) => {
+  const major = left.major - right.major;
+  const minor = left.minor - right.minor;
+  const patch = left.patch - right.patch;
+  return major || minor || patch;
+};
+
+const toInt = (text) => parseInt(text, 10);
+
+const clamp = (value, min, max) => Math.max(min, Math.min(max, value));
+
+const resource = (dir, name) => fs.readFileSync(path.join(dir, name), 'utf8');
+
+const readText = (file) => {
+  try {
+    return fs.readFileSync(file, 'utf8');
+  } catch {
+    return '';
+  }
+};
+
+const readJson = (file) => jsonParse(readText(file));
+
+const writeJson = (file, data) => {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(data, null, 2)}\n`);
+};
+
+const listDir = (dir) => {
+  try {
+    return fs.readdirSync(dir);
+  } catch {
+    return [];
+  }
+};
+
+const errorMessage = (reason) => {
+  if (reason instanceof Error) return reason.message;
+  return `${reason ?? ''}`;
+};
+
+const trimText = (value) => `${value ?? ''}`.trim();
+
+const oneLine = (text, fallback = '') => {
+  const body = `${text ?? ''}`.trim();
+  const first = split(body, '\n')[0];
+  return first || fallback;
+};
+
+const withNewline = (text) => {
+  const body = `${text ?? ''}`;
+  return !body || body.endsWith('\n') ? body : `${body}\n`;
+};
+
+const withNotice = (text, notice) => {
+  const body = `${text ?? ''}`;
+  if (body.endsWith(`${notice}\n`)) return body;
+  return `${withNewline(body)}${notice}\n`;
+};
+
+const asText = (value) => (typeof value === 'string' ? value : '');
+
+const unquote = (value) => {
+  const text = `${value ?? ''}`;
+  if (text.length < 2) return text;
+  const open = text[0];
+  const quoted = open === text.at(-1) && (open === '"' || open === '\x27');
+  return quoted ? text.slice(1, -1) : text;
+};
+
+const pad2 = (n) => `${n}`.padStart(2, '0');
+
+const dateStamp = (date) => {
+  const month = pad2(date.getMonth() + 1);
+  return `${date.getFullYear()}-${month}-${pad2(date.getDate())}`;
+};
+
+module.exports = {
+  parseVersion,
+  cmpVersion,
+  toInt,
+  clamp,
+  resource,
+  readText,
+  readJson,
+  writeJson,
+  listDir,
+  errorMessage,
+  trimText,
+  oneLine,
+  asText,
+  withNewline,
+  withNotice,
+  unquote,
+  pad2,
+  dateStamp,
+};

package/lib/dashboard/git.js

@@ -2,9 +2,9 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
+const { readText } = require('../common/utilities.js');
 
-const worktree = require('../git-worktree.js');
-const { runGitAsync } = worktree;
+const { runGit } = require('../git/worktree.js');
 
 const UNIT = '\x1f';
 const RECENT_COUNT = 8;
@@ -29,7 +29,7 @@ const TRACK_BEHIND = /behind (\d+)/;
 
 const gitText = async (top, args) => {
   try {
-    const result = await runGitAsync(args, top);
+    const result = await runGit(args, top);
     return result.status === 0 ? result.stdout.trim() : '';
   } catch {
     return '';
@@ -49,11 +49,10 @@ const parseTrack = (text) => {
   const raw = `${text ?? ''}`;
   const ahead = TRACK_AHEAD.exec(raw);
   const behind = TRACK_BEHIND.exec(raw);
-  return {
-    ahead: ahead ? Number(ahead[1]) : 0,
-    behind: behind ? Number(behind[1]) : 0,
-    gone: raw.includes('gone'),
-  };
+  const aheadCount = ahead ? Number(ahead[1]) : 0;
+  const behindCount = behind ? Number(behind[1]) : 0;
+  const gone = raw.includes('gone');
+  return { ahead: aheadCount, behind: behindCount, gone };
 };
 
 const parseBranch = (line) => {
@@ -82,13 +81,7 @@ const parseCommit = (line) => {
   };
 };
 
-const readNumber = (file) => {
-  try {
-    return countOf(fs.readFileSync(file, 'utf8'));
-  } catch {
-    return 0;
-  }
-};
+const readNumber = (file) => countOf(readText(file));
 
 const readStep = (dir, step, total) => ({
   step: readNumber(path.join(dir, step)),
@@ -125,4 +118,4 @@ const readGitSummary = async (top) => {
   };
 };
 
-module.exports = { readGitSummary, parseTrack };
+module.exports = { gitText, countOf, readGitSummary, parseTrack };

package/lib/dashboard/model.js

@@ -1,58 +1,33 @@
 'use strict';
 
-const tree = require('./tree.js');
-const { folderOf, extOf } = tree;
-const files = require('../files.js');
-const { TASK_KINDS, taskKind } = files;
+const path = require('node:path');
+const { trimText } = require('../common/utilities.js');
+const { ageSeconds } = require('../common/format.js');
+
+const { folderOf, extOf } = require('./tree.js');
+const { TASK_KINDS, taskKind } = require('../common/files.js');
 
 const MINUTE_MS = 60_000;
 const RUNS_SHOWN = 6;
 const CHAIN_GAP_MS = 2000;
 const NPM_NAMED = /^npm (?:run|exec)(?:\s+-s)?\s+(\S+)/;
 const NPM_ALIAS = /^npm (test|start|stop|restart)(?:\s|$)/;
-const AGE_TEXT = /^(\d+)\s+(second|minute|hour|day|week|month|year)s?\s+ago$/i;
-const AGE_SEC = {
-  second: 1,
-  minute: 60,
-  hour: 3600,
-  day: 86400,
-  week: 604800,
-  month: 2592000,
-  year: 31536000,
-};
 const STATUS_RANK = { running: 3, failed: 2, aborted: 1, passed: 0 };
 
 const namedScript = (command) => {
-  const text = `${command ?? ''}`.trim();
+  const text = trimText(command);
   const named = NPM_NAMED.exec(text);
   if (named) return named[1];
   const alias = NPM_ALIAS.exec(text);
   return alias ? alias[1] : '';
 };
 
-const scriptName = (command) => {
-  const named = namedScript(command);
-  if (named) return named;
-  const text = `${command ?? ''}`.trim();
-  const token = text.split(/\s+/)[0];
-  const slash = Math.max(token.lastIndexOf('/'), token.lastIndexOf('\\'));
-  return token.slice(slash + 1) || text;
-};
-
 const runName = (record) => {
-  const command = `${record.command ?? ''}`.trim();
-  const script = `${record.script ?? ''}`.trim();
+  const command = trimText(record.command);
+  const script = trimText(record.script);
   return namedScript(command) || script || command;
 };
 
-const ageSeconds = (text) => {
-  const raw = `${text ?? ''}`.trim();
-  if (/^yesterday$/i.test(raw)) return AGE_SEC.day;
-  const match = AGE_TEXT.exec(raw);
-  if (!match) return Number.POSITIVE_INFINITY;
-  return Number(match[1]) * AGE_SEC[match[2].toLowerCase()];
-};
-
 const newerDate = (current, next) => {
   if (!next) return current;
   if (!current || ageSeconds(next) < ageSeconds(current)) return next;
@@ -130,17 +105,32 @@ const externalRun = (record) => {
   };
 };
 
+const sessionName = (run) => {
+  const named = namedScript(run.label);
+  if (named) return named;
+  const script = trimText(run.name);
+  if (script) return script;
+  return trimText(run.command ?? run.label);
+};
+
+const progressOf = (run) => {
+  const progress = run.progress ?? {};
+  return {
+    done: progress.done ?? 0,
+    failed: progress.failed ?? 0,
+    expected: progress.expected ?? 0,
+  };
+};
+
 const internalRun = (run) => ({
   source: 'reslop',
-  name: scriptName(run.label),
+  name: sessionName(run),
   status: npmRunStatus(run),
   exit: run.exit,
   startedAt: run.startedAt,
   endedAt: run.endedAt,
-  done: 0,
-  failed: 0,
-  expected: 0,
-  result: null,
+  ...progressOf(run),
+  result: run.result ?? null,
 });
 
 const rankOf = (status) => STATUS_RANK[status] ?? 0;
@@ -175,6 +165,26 @@ const continuesRun = (prev, next) => {
   return next.startedAt <= prev.endedAt + CHAIN_GAP_MS;
 };
 
+const chainedStep = (prev, next) => {
+  if (prev.name !== next.name || prev.command === next.command) return false;
+  const end = Number(prev.endedAt) || 0;
+  const at = Number(next.startedAt) || 0;
+  return end > 0 && at >= end && at <= end + CHAIN_GAP_MS;
+};
+
+const foldSteps = (runs) => {
+  const ordered = [...runs].sort(
+    (left, right) => (left.startedAt || 0) - (right.startedAt || 0),
+  );
+  const groups = [];
+  for (const run of ordered) {
+    const prev = groups.at(-1);
+    if (prev && chainedStep(prev, run)) groups[groups.length - 1] = run;
+    else groups.push(run);
+  }
+  return groups.reverse();
+};
+
 const absorbRun = (prev, next) => {
   const open = isOpen(prev) || isOpen(next);
   if (rankOf(next.status) >= rankOf(prev.status)) {
@@ -201,25 +211,55 @@ const collapseRuns = (list) => {
   return groups.sort((left, right) => right.startedAt - left.startedAt);
 };
 
-const mergeRuns = (records, npmRun) => {
-  const list = records.map(externalRun);
-  if (npmRun) list.push(internalRun(npmRun));
-  return collapseRuns(list).slice(0, RUNS_SHOWN);
+const overlaps = (row, run) => {
+  if (row.name !== sessionName(run)) return false;
+  const start = Number(run.startedAt) || 0;
+  const end = Number(run.endedAt) || start;
+  const at = Number(row.startedAt) || 0;
+  const low = start - CHAIN_GAP_MS;
+  const high = Math.max(start, end) + CHAIN_GAP_MS;
+  return at >= low && at <= high;
+};
+
+const applySession = (row, run) => {
+  if (!run.running) return;
+  const next = internalRun(run);
+  row.status = next.status;
+  row.exit = next.exit;
+  row.done = next.done;
+  row.failed = next.failed;
+  row.expected = Math.max(row.expected, next.expected);
+  row.endedAt = 0;
+  if (next.result) row.result = next.result;
+};
+
+const mergeRuns = (records, npmRuns) => {
+  const sessions = Array.isArray(npmRuns) ? npmRuns : [];
+  const list = collapseRuns(records.map(externalRun));
+  for (const run of sessions) {
+    const row = list.find((item) => overlaps(item, run));
+    if (row) applySession(row, run);
+    else list.push(internalRun(run));
+  }
+  list.sort((left, right) => right.startedAt - left.startedAt);
+  return list.slice(0, RUNS_SHOWN);
 };
 
 const taskKindCounts = (store) => {
   const kinds = TASK_KINDS.map((kind) => ({
     id: kind.id,
-    title: kind.title,
+    title: kind.short,
     done: 0,
     total: 0,
   }));
   const byId = new Map(kinds.map((row) => [row.id, row]));
   let done = 0;
   let total = 0;
-  if (!store) return { kinds, done, total };
+  const file = store && store.reviewPath ? store.reviewPath : '';
+  const plan = file ? path.basename(file) : '';
+  if (!store) return { kinds, done, total, plan };
   for (const task of store.tasks) {
-    if (!`${task.text ?? ''}`.trim()) continue;
+    if (!trimText(task.text)) continue;
     const row = byId.get(taskKind(task));
     row.total += 1;
     total += 1;
@@ -227,7 +267,7 @@ const taskKindCounts = (store) => {
     row.done += 1;
     done += 1;
   }
-  return { kinds, done, total };
+  return { kinds, done, total, plan };
 };
 
 const versionFields = (pkg, outdatedMap) => {
@@ -341,16 +381,17 @@ const buildModel = (input) => ({
   commits: commitsModel(input),
   branches: branchesModel(input),
   npm: npmModel(input),
-  runs: mergeRuns(input.runs, input.npmRun),
+  runs: mergeRuns(input.runs, input.npmRuns),
   tasks: tasksModel(input),
+  agents: input.agents ?? { ready: true, installed: 0, total: 0, items: [] },
 });
 
 module.exports = {
   MINUTE_MS,
   minuteOf,
   groupChanges,
+  foldSteps,
   mergeRuns,
-  scriptName,
   runName,
   npmModel,
   buildModel,

package/lib/dashboard/npm.js

@@ -2,11 +2,10 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
+const { jsonParse } = require('metautil');
 
-const deps = require('../deps.js');
-const { MANIFEST } = deps;
-const watch = require('../session/watch.js');
-const { MODULES_STAMP } = watch;
+const { MANIFEST } = require('../deps/deps.js');
+const { MODULES_STAMP } = require('./watch.js');
 
 const MODULES = 'node_modules';
 const MODULE_PREFIX = `${MODULES}/`;
@@ -15,7 +14,8 @@ const TOP_PACKAGES = 8;
 
 const readJson = async (file) => {
   try {
-    return JSON.parse(await fs.promises.readFile(file, 'utf8'));
+    const text = await fs.promises.readFile(file, 'utf8');
+    return jsonParse(text);
   } catch {
     return null;
   }
@@ -54,10 +54,12 @@ const packageName = (root, file) => {
 const rankedPackages = (totals) => {
   const list = [];
   for (const [name, bytes] of totals) list.push({ name, bytes });
-  return list.sort(
-    (left, right) =>
-      right.bytes - left.bytes || left.name.localeCompare(right.name, 'en'),
-  );
+  const bySize = (left, right) => {
+    const byBytes = right.bytes - left.bytes;
+    const byName = left.name.localeCompare(right.name, 'en');
+    return byBytes || byName;
+  };
+  return list.sort(bySize);
 };
 
 const DIRECT_SECTIONS = [
@@ -205,12 +207,13 @@ const measureModules = async (root) => {
   const worker = async () => {
     while (queue.length) {
       const dir = queue.pop();
-      let entries;
+      let entries = null;
       try {
         entries = await fs.promises.readdir(dir, { withFileTypes: true });
       } catch {
-        continue;
+        // unreadable directory
       }
+      if (!entries) continue;
       const files = [];
       for (const entry of entries) {
         const full = path.join(dir, entry.name);
@@ -245,12 +248,13 @@ const installedCount = async (top, lock) => {
     }
     return count;
   }
-  let entries;
+  let entries = null;
   try {
     entries = await fs.promises.readdir(path.join(top, MODULES));
   } catch {
-    return 0;
+    // missing modules
   }
+  if (!entries) return 0;
   let count = 0;
   for (const name of entries) {
     if (name.startsWith('.')) continue;

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;
   }