reslop 0.2.6 → 0.3.0

package/lib/common/tasks.json

@@ -0,0 +1,27 @@
+{
+  "label": "Project Tasks: Feature requests, Improvements, Bug reports, Refactoring, Research, Security",
+  "kinds": [
+    {
+      "id": "features",
+      "title": "Feature requests and Enhancements",
+      "short": "Features"
+    },
+    { "id": "improvements", "title": "Improvements", "short": "Improvements" },
+    { "id": "bugs", "title": "Bug Reports and Fixes", "short": "Bug Reports" },
+    {
+      "id": "debt",
+      "title": "Refactoring and Technical debt",
+      "short": "Refactoring"
+    },
+    {
+      "id": "research",
+      "title": "Research and Experiments",
+      "short": "Research"
+    },
+    {
+      "id": "security",
+      "title": "Security and Compliance",
+      "short": "Security"
+    }
+  ]
+}

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,57 +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;
@@ -129,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;
@@ -174,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)) {
@@ -200,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;
@@ -226,7 +267,7 @@ const taskKindCounts = (store) => {
     row.done += 1;
     done += 1;
   }
-  return { kinds, done, total };
+  return { kinds, done, total, plan };
 };
 
 const versionFields = (pkg, outdatedMap) => {
@@ -237,12 +278,25 @@ const versionFields = (pkg, outdatedMap) => {
   return { current, wanted: hit.wanted, latest: hit.latest };
 };
 
+const auditFields = (pkg, auditMap) => {
+  const finding = auditMap ? auditMap.get(pkg.name) : null;
+  return {
+    audit: Boolean(finding),
+    fix: finding && finding.fix ? finding.fix : '',
+    range: finding && finding.range ? finding.range : '',
+    severity: finding && finding.severity ? finding.severity : '',
+    title: finding && finding.title ? finding.title : '',
+  };
+};
+
 const modulesModel = (modules, auditMap, outdatedMap) => {
   const packages = modules.packages.map((pkg) => ({
     name: pkg.name,
     bytes: pkg.bytes,
     dev: pkg.dev,
-    audit: Boolean(auditMap && auditMap.get(pkg.name)),
+    transitive: Boolean(pkg.transitive),
+    chain: pkg.chain || '',
+    ...auditFields(pkg, auditMap),
     ...versionFields(pkg, outdatedMap),
   }));
   return { ...modules, packages };
@@ -266,6 +320,8 @@ const npmModel = (input) => {
   };
 };
 
+const minuteOf = (at) => Math.floor((at || 0) / MINUTE_MS);
+
 const filesModel = (input) => {
   const index = input.index;
   const ready = Boolean(index && index.ready);
@@ -288,7 +344,7 @@ const diffsModel = (input) => {
     dirs: groups.dirs,
     exts: groups.exts,
     files: input.entries.length,
-    samples: input.samples,
+    activity: input.activity ?? { minutes: [], live: false },
     delta: input.diffDelta,
   };
 };
@@ -325,8 +381,18 @@ 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 = { groupChanges, mergeRuns, scriptName, runName, buildModel };
+module.exports = {
+  MINUTE_MS,
+  minuteOf,
+  groupChanges,
+  foldSteps,
+  mergeRuns,
+  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,13 +54,36 @@ 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 = [
+  'dependencies',
+  'devDependencies',
+  'optionalDependencies',
+  'peerDependencies',
+];
+const CHILD_SECTIONS = [
+  'dependencies',
+  'optionalDependencies',
+  'peerDependencies',
+];
+const CHAIN_MARK = ' 🢒 ';
+
+const directNames = (pkg) => {
+  const names = new Set();
+  for (const section of DIRECT_SECTIONS) {
+    for (const name of declaredNames(pkg, section)) names.add(name);
+  }
+  return names;
 };
 
-const devOnlyNames = (pkg, lock) => {
+const devNames = (pkg) => {
   const keep = new Set([
     ...declaredNames(pkg, 'dependencies'),
     ...declaredNames(pkg, 'optionalDependencies'),
@@ -69,16 +92,84 @@ const devOnlyNames = (pkg, lock) => {
   for (const name of declaredNames(pkg, 'devDependencies')) {
     if (!keep.has(name)) names.add(name);
   }
+  return names;
+};
+
+const entryName = (key) => {
+  const at = key.lastIndexOf(MODULE_PREFIX);
+  if (at < 0) return '';
+  const rest = key.slice(at + MODULE_PREFIX.length);
+  if (rest.startsWith('@')) {
+    const parts = rest.split('/');
+    if (!parts[1]) return '';
+    return `${parts[0]}/${parts[1]}`;
+  }
+  return rest.split('/')[0] || '';
+};
+
+const childNames = (entry) => {
+  const names = [];
+  if (!entry || typeof entry !== 'object') return names;
+  for (const section of CHILD_SECTIONS) {
+    const map = entry[section];
+    if (!map || typeof map !== 'object') continue;
+    for (const name of Object.keys(map)) {
+      if (!names.includes(name)) names.push(name);
+    }
+  }
+  return names;
+};
+
+const dependencyChildren = (lock) => {
+  const children = new Map();
   const packages = lockPackages(lock);
-  if (!packages) return names;
+  if (!packages) return children;
   for (const key of Object.keys(packages)) {
-    const entry = packages[key];
-    if (!entry || !entry.dev || !key.startsWith(MODULE_PREFIX)) continue;
-    const name = key.slice(MODULE_PREFIX.length);
-    if (!name || name.includes('/node_modules/') || keep.has(name)) continue;
-    names.add(name);
+    if (!key) continue;
+    const name = entryName(key);
+    if (!name) continue;
+    const list = children.get(name) ?? [];
+    for (const child of childNames(packages[key])) {
+      if (!list.includes(child)) list.push(child);
+    }
+    if (list.length) children.set(name, list);
   }
-  return names;
+  return children;
+};
+
+const parentChain = (name, declared, children) => {
+  if (declared.has(name)) return '';
+  const prev = new Map();
+  const queue = [];
+  const roots = [...declared].sort();
+  for (const root of roots) {
+    if (prev.has(root)) continue;
+    prev.set(root, '');
+    queue.push(root);
+  }
+  let head = 0;
+  while (head < queue.length) {
+    const at = queue[head];
+    head += 1;
+    const kids = children.get(at);
+    if (!kids) continue;
+    for (const kid of kids) {
+      if (prev.has(kid)) continue;
+      prev.set(kid, at);
+      if (kid !== name) {
+        queue.push(kid);
+        continue;
+      }
+      const path = [];
+      let cursor = at;
+      while (cursor) {
+        path.push(cursor);
+        cursor = prev.get(cursor) || '';
+      }
+      return path.join(CHAIN_MARK);
+    }
+  }
+  return '';
 };
 
 const lockVersion = (lock, name) => {
@@ -89,16 +180,24 @@ const lockVersion = (lock, name) => {
 };
 
 const topPackages = (ranked, pkg, lock) => {
-  const devNames = devOnlyNames(pkg, lock);
-  const rows = ranked.map((item) => ({
-    name: item.name,
-    bytes: item.bytes,
-    dev: devNames.has(item.name),
-    version: lockVersion(lock, item.name),
-  }));
-  const runtime = rows.filter((row) => !row.dev);
-  const devs = rows.filter((row) => row.dev);
-  return [...runtime, ...devs].slice(0, TOP_PACKAGES);
+  const declared = directNames(pkg);
+  const devs = devNames(pkg);
+  const children = dependencyChildren(lock);
+  const rows = ranked.map((item) => {
+    const direct = declared.has(item.name);
+    return {
+      name: item.name,
+      bytes: item.bytes,
+      dev: direct && devs.has(item.name),
+      transitive: !direct,
+      chain: parentChain(item.name, declared, children),
+      version: lockVersion(lock, item.name),
+    };
+  });
+  const runtime = rows.filter((row) => !row.dev && !row.transitive);
+  const development = rows.filter((row) => row.dev);
+  const nested = rows.filter((row) => row.transitive);
+  return [...runtime, ...development, ...nested];
 };
 
 const measureModules = async (root) => {
@@ -108,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);
@@ -148,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;
@@ -190,4 +291,4 @@ const readNpmSummary = async (top, previous) => {
   };
 };
 
-module.exports = { readNpmSummary };
+module.exports = { TOP_PACKAGES, readNpmSummary };