reslop 0.2.1 → 0.2.4

package/lib/report-tools.js

@@ -0,0 +1,337 @@
+'use strict';
+
+const deps = require('./deps.js');
+const { parseAuditReport, parseOutdatedReport } = deps;
+const model = require('./report-model.js');
+
+const { summary, problem, report, userTrace } = model;
+
+const place = (file, line, column, root) =>
+  userTrace(`${file}:${line}:${column}`, root);
+
+const parseEslintJson = (data, root) => {
+  const rows = Array.isArray(data) ? data : data && data.results;
+  if (!Array.isArray(rows) || !rows.length) return null;
+  if (!rows[0] || !Array.isArray(rows[0].messages)) return null;
+  const stats = summary();
+  let errors = 0;
+  let warnings = 0;
+  const problems = [];
+  for (const file of rows) {
+    const messages = file.messages || [];
+    for (const item of messages) {
+      const severity = item.severity === 1 ? 'warning' : 'error';
+      if (severity === 'warning') warnings += 1;
+      else errors += 1;
+      problems.push(
+        problem({
+          severity,
+          message: item.message || '',
+          code: item.ruleId || '',
+          trace: place(
+            file.filePath || '',
+            item.line || 0,
+            item.column || 0,
+            root,
+          ),
+        }),
+      );
+    }
+  }
+  stats.errors = errors;
+  stats.warnings = warnings;
+  return report('eslint', { summary: stats, problems });
+};
+
+const eslintLine = (line) => {
+  const match = /^\s*(\d+):(\d+)\s+(error|warning)\s+(.*)$/.exec(line);
+  if (!match) return null;
+  const rest = match[4];
+  const ruleAt = rest.lastIndexOf('  ');
+  const message = ruleAt < 0 ? rest : rest.slice(0, ruleAt);
+  const code = ruleAt < 0 ? '' : rest.slice(ruleAt + 2).trim();
+  return {
+    line: match[1],
+    column: match[2],
+    severity: match[3],
+    message: message.trim(),
+    code,
+  };
+};
+
+const isPathLine = (line) => {
+  const text = line.trim();
+  if (!text || text.startsWith('✖')) return false;
+  if (eslintLine(text)) return false;
+  return text.includes('/') || text.includes('\\') || /\.\w+$/.test(text);
+};
+
+const parseEslintStylish = (text, root) => {
+  const lines = `${text ?? ''}`.split(/\r?\n/);
+  const problems = [];
+  let file = '';
+  let errors = 0;
+  let warnings = 0;
+  let seen = false;
+  for (const line of lines) {
+    const item = eslintLine(line);
+    if (item) {
+      seen = true;
+      if (item.severity === 'warning') warnings += 1;
+      else errors += 1;
+      problems.push(
+        problem({
+          severity: item.severity,
+          message: item.message,
+          code: item.code,
+          trace: place(file, item.line, item.column, root),
+        }),
+      );
+      continue;
+    }
+    if (/✖\s+\d+\s+problems?\b/.test(line)) seen = true;
+    if (isPathLine(line)) file = line.trim();
+  }
+  if (!seen) return null;
+  const stats = summary();
+  stats.errors = errors;
+  stats.warnings = warnings;
+  return report('eslint', { summary: stats, problems });
+};
+
+const tscLine = (line) => {
+  const match = /^(.*)\((\d+),(\d+)\):\s+error\s+(TS\d+):\s+(.*)$/.exec(
+    line.trim(),
+  );
+  if (!match) return null;
+  return {
+    file: match[1],
+    line: match[2],
+    column: match[3],
+    code: match[4],
+    message: match[5],
+  };
+};
+
+const parseTsc = (text, root) => {
+  const problems = [];
+  for (const line of `${text ?? ''}`.split(/\r?\n/)) {
+    const item = tscLine(line);
+    if (!item) continue;
+    problems.push(
+      problem({
+        message: item.message,
+        code: item.code,
+        trace: place(item.file, item.line, item.column, root),
+      }),
+    );
+  }
+  if (!problems.length) return null;
+  const stats = summary();
+  stats.errors = problems.length;
+  return report('tsc', { summary: stats, problems });
+};
+
+const prettierFile = (line) => {
+  const warn = /^\[(?:warn|error)\]\s+(\S+)$/.exec(line.trim());
+  if (warn && !warn[1].startsWith('Code')) return warn[1];
+  return '';
+};
+
+const parsePrettier = (text, root) => {
+  const lines = `${text ?? ''}`.split(/\r?\n/);
+  const problems = [];
+  let seen = false;
+  for (const line of lines) {
+    if (line.includes('Code style issues')) seen = true;
+    if (line.includes('All matched files use Prettier')) seen = true;
+    const file = prettierFile(line);
+    if (!file) continue;
+    seen = true;
+    problems.push(
+      problem({
+        message: 'format',
+        trace: userTrace(file, root),
+      }),
+    );
+  }
+  if (!seen) return null;
+  const stats = summary();
+  stats.errors = problems.length;
+  return report('prettier', { summary: stats, problems });
+};
+
+const auditExtra = (item) => {
+  const size = (item.range ? 1 : 0) + (item.fix ? 1 : 0);
+  const extra = new Array(size);
+  let index = 0;
+  if (item.range) {
+    extra[index] = ['range', item.range];
+    index += 1;
+  }
+  if (item.fix) extra[index] = ['fix', item.fix];
+  return extra;
+};
+
+const auditProblems = (text) => {
+  const audit = parseAuditReport(text);
+  const problems = new Array(audit.size);
+  let index = 0;
+  for (const item of audit.values()) {
+    problems[index] = problem({
+      severity: item.severity || 'error',
+      name: item.name,
+      message: item.title || '',
+      extra: auditExtra(item),
+    });
+    index += 1;
+  }
+  return problems;
+};
+
+const parseAudit = (text) => {
+  const problems = auditProblems(text);
+  if (!problems.length) return null;
+  const stats = summary();
+  stats.errors = problems.length;
+  return report('audit', { summary: stats, problems });
+};
+
+const behind = (item) => {
+  if (!item.current) return true;
+  if (item.wanted && item.wanted !== item.current) return true;
+  if (item.latest && item.latest !== item.current) return true;
+  return false;
+};
+
+const parseOutdated = (text) => {
+  const outdated = parseOutdatedReport(text);
+  const problems = [];
+  for (const [name, item] of outdated) {
+    if (!behind(item)) continue;
+    problems.push(
+      problem({
+        severity: 'warning',
+        name,
+        message: `${item.current} ${item.wanted} ${item.latest}`.trim(),
+        extra: [
+          ['current', item.current],
+          ['wanted', item.wanted],
+          ['latest', item.latest],
+        ],
+      }),
+    );
+  }
+  if (!problems.length) return null;
+  const stats = summary();
+  stats.warnings = problems.length;
+  return report('outdated', { summary: stats, problems });
+};
+
+const pushLs = (problems, text) => {
+  const message = `${text ?? ''}`.trim();
+  if (!message) return;
+  problems.push(problem({ message }));
+};
+
+const walkLs = (node, problems) => {
+  if (!node || typeof node !== 'object') return;
+  if (Array.isArray(node.problems)) {
+    for (const item of node.problems) pushLs(problems, item);
+  }
+  if (node.missing) {
+    pushLs(problems, `missing ${node.required || node.version || ''}`);
+  }
+  if (node.invalid) pushLs(problems, `invalid ${node.version || ''}`);
+  if (node.extraneous) pushLs(problems, `extraneous ${node.version || ''}`);
+  const deps = node.dependencies;
+  if (!deps || typeof deps !== 'object') return;
+  for (const name of Object.keys(deps)) walkLs(deps[name], problems);
+};
+
+const parseLs = (data) => {
+  if (!data || typeof data !== 'object' || Array.isArray(data)) return null;
+  if (!data.dependencies && !Array.isArray(data.problems)) return null;
+  const problems = [];
+  walkLs(data, problems);
+  if (!problems.length && !Array.isArray(data.problems)) return null;
+  const stats = summary();
+  stats.errors = problems.length;
+  return report('ls', { summary: stats, problems });
+};
+
+const parseToolJson = (data, root) => {
+  const eslint = parseEslintJson(data, root);
+  if (eslint) return [eslint];
+  const vulns = data && (data.vulnerabilities || data.advisories);
+  const audit = vulns ? parseAudit(JSON.stringify(data)) : null;
+  if (audit) return [audit];
+  const ls = parseLs(data);
+  if (ls) return [ls];
+  const outdated = parseOutdated(JSON.stringify(data));
+  if (outdated) return [outdated];
+  return null;
+};
+
+const parseAuditText = (text) => {
+  if (`${text ?? ''}`.trim().startsWith('{')) return null;
+  const lines = `${text ?? ''}`.split(/\r?\n/);
+  const problems = [];
+  for (let index = 0; index < lines.length; index++) {
+    const match = /^Severity:\s+(\w+)\s*$/.exec(lines[index].trim());
+    if (!match) continue;
+    const name = (lines[index - 1] || '').trim();
+    problems.push(
+      problem({
+        severity: match[1].toLowerCase(),
+        name,
+        message: name,
+      }),
+    );
+  }
+  if (!problems.length) return null;
+  const stats = summary();
+  stats.errors = problems.length;
+  return report('audit', { summary: stats, problems });
+};
+
+const TOOL_SLOTS = 4;
+
+const parseToolText = (text, root) => {
+  const reports = new Array(TOOL_SLOTS);
+  let index = 0;
+  const eslint = parseEslintStylish(text, root);
+  if (eslint) {
+    reports[index] = eslint;
+    index += 1;
+  }
+  const tsc = parseTsc(text, root);
+  if (tsc) {
+    reports[index] = tsc;
+    index += 1;
+  }
+  const prettier = parsePrettier(text, root);
+  if (prettier) {
+    reports[index] = prettier;
+    index += 1;
+  }
+  const audit = parseAuditText(text);
+  if (audit) {
+    reports[index] = audit;
+    index += 1;
+  }
+  reports.length = index;
+  return reports;
+};
+
+module.exports = {
+  parseEslintJson,
+  parseEslintStylish,
+  parseTsc,
+  parsePrettier,
+  parseAudit,
+  parseOutdated,
+  parseLs,
+  parseToolJson,
+  parseToolText,
+};

package/lib/review-merge.js

@@ -1,6 +1,7 @@
 'use strict';
 
-const { TODO_FILE } = require('./files.js');
+const files = require('./files.js');
+const { TODO_FILE } = files;
 
 const flatText = (text) => `${text ?? ''}`.trim().replace(/\n/g, ' ');
 

package/lib/review.js

@@ -3,8 +3,10 @@
 const fs = require('node:fs');
 const path = require('node:path');
 
-const { TODO_FILE, REVIEW_DIR } = require('./files.js');
-const { captureBaseline, mergeReview } = require('./review-merge.js');
+const files = require('./files.js');
+const { TODO_FILE, REVIEW_DIR } = files;
+const reviewMerge = require('./review-merge.js');
+const { captureBaseline, mergeReview } = reviewMerge;
 
 const createStore = (reviewPath, templates = []) => ({
   reviewPath,
@@ -240,6 +242,8 @@ const AGENT_INSTRUCTIONS = [
   '- If not `editing`, set `status` to `partial` if some remain, ' +
     'or `done` if all are `[x]`',
   '- Do not redo items already marked `[x]`',
+  '- Run the full check with `npm t`',
+  '- Run specific test files with `reslop t -- node --test <files>`',
 ].join('\n');
 
 const toInt = (text) => parseInt(text, 10);

package/lib/session/actions.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const LIST_PANES = ['files', 'branches', 'commits', 'npm'];
+
 const ACTIONS = {
   add: ['a'],
   unstage: ['u'],
@@ -33,21 +35,40 @@ const COMMIT_ACTIONS = {
   reword: ['r'],
   fixup: ['f'],
   drop: ['d'],
+  view: ['v'],
   pull: ['p'],
   push: ['s'],
 };
 
+const NPM_ACTIONS = {
+  npm: ['n'],
+  npmEdit: ['e'],
+  npmNew: ['n'],
+  npmDrop: ['d'],
+  npmLogs: ['c'],
+  npmStop: ['escape'],
+  npmRerun: ['r'],
+};
+
 const ACTION_HOT = {
   prev: '←',
   next: '→',
+  npmStop: 'esc',
 };
 
 const ACTION_LABEL = {
   revert: 'drop',
   check: 'x',
   layout: 'mode',
+  view: 'view',
   code: 'edit',
   newBranch: 'new',
+  npmEdit: 'edit',
+  npmNew: 'new',
+  npmDrop: 'delete',
+  npmLogs: 'cleanup',
+  npmStop: 'esc',
+  npmRerun: 're-run',
   quit: 'q',
   prev: '←',
   next: '→',
@@ -106,21 +127,8 @@ const BRANCHES_DISABLED = [
   'prev',
   'next',
 ];
-const COMMITS_DISABLED = [
-  'add',
-  'unstage',
-  'revert',
-  'layout',
-  'feedback',
-  'todo',
-  'code',
-  'check',
-  'branch',
-  'file',
-  'diff',
-  'prev',
-  'next',
-];
+const COMMITS_DISABLED = BRANCHES_DISABLED.filter((id) => id !== 'commit');
+const NPM_DISABLED = [...BRANCHES_DISABLED, 'pull', 'push'];
 
 const isTodosTarget = (item) =>
   !!(item && (item.kind === 'todos' || item.origin === 'todo'));
@@ -143,8 +151,16 @@ const isFixupCommit = (item) =>
   `${item && item.subject ? item.subject : ''}`.startsWith('fixup!');
 
 const commitWriteDisabled = (item) => {
-  if (!item || !item.sha) return ['amend', 'apply', 'reword', 'fixup', 'drop'];
-  return [];
+  const pending = Boolean(item && item.pending);
+  const unstaged = Boolean(item && item.unstagedCurrent);
+  if (!item || !item.sha) {
+    const off = ['reword', 'fixup', 'drop'];
+    if (pending) return off;
+    return ['amend', 'apply', ...off];
+  }
+  if (unstaged) return [];
+  if (isFixupCommit(item)) return ['amend'];
+  return ['amend', 'apply'];
 };
 
 const commitGitDisabled = (item) => {
@@ -164,6 +180,7 @@ const disabledActions = (pane, item) => {
   if (pane === 'commits') {
     return [...COMMITS_DISABLED, ...commitWriteDisabled(item)];
   }
+  if (pane === 'npm') return NPM_DISABLED;
   if (onTodos) return TODO_DISABLED;
   return [...DIFF_DISABLED, ...diffGitDisabled(item)];
 };
@@ -190,41 +207,50 @@ const SCROLL = {
   delete: 'removeTodo',
 };
 
-const KEY_TO_ACTION = {};
+const keysForActions = (actions) => {
+  const keys = {};
+  for (const [id, shortcuts] of Object.entries(actions)) {
+    for (const key of shortcuts) keys[key] = id;
+  }
+  return keys;
+};
+
 const PANE_ONLY = ['branch', 'file', 'diff'];
-const FILES_KEYS = {};
-for (const key of ACTIONS.branch) FILES_KEYS[key] = 'branch';
-for (const id of BRANCH_REMOTE) {
-  for (const key of BRANCH_ACTIONS[id]) FILES_KEYS[key] = id;
-}
-const BRANCH_KEYS = {};
-for (const id of Object.keys(BRANCH_ACTIONS)) {
-  for (const key of BRANCH_ACTIONS[id]) BRANCH_KEYS[key] = id;
-}
-const COMMIT_KEYS = {};
-for (const id of Object.keys(COMMIT_ACTIONS)) {
-  for (const key of COMMIT_ACTIONS[id]) COMMIT_KEYS[key] = id;
-}
+const FILES_KEYS = keysForActions({
+  branch: ACTIONS.branch,
+  pull: BRANCH_ACTIONS.pull,
+  push: BRANCH_ACTIONS.push,
+  npm: NPM_ACTIONS.npm,
+});
+const BRANCH_KEYS = keysForActions(BRANCH_ACTIONS);
+const COMMIT_KEYS = keysForActions(COMMIT_ACTIONS);
+const NPM_KEYS = {
+  e: 'npmEdit',
+  n: 'npmNew',
+  d: 'npmDrop',
+  c: 'npmLogs',
+};
 const PANE_KEYS = {
   files: FILES_KEYS,
   branches: BRANCH_KEYS,
   commits: COMMIT_KEYS,
+  npm: NPM_KEYS,
 };
 
-for (const id of ACTION_IDS) {
-  if (PANE_ONLY.includes(id)) continue;
-  for (const key of ACTIONS[id]) KEY_TO_ACTION[key] = id;
-}
-
-for (const key of Object.keys(SCROLL)) KEY_TO_ACTION[key] = SCROLL[key];
-for (const key of Object.keys(HIDDEN_KEYS)) {
-  KEY_TO_ACTION[key] = HIDDEN_KEYS[key];
-}
+const KEY_TO_ACTION = {
+  ...keysForActions(
+    Object.fromEntries(
+      Object.entries(ACTIONS).filter(([id]) => !PANE_ONLY.includes(id)),
+    ),
+  ),
+  ...SCROLL,
+  ...HIDDEN_KEYS,
+};
 
 const actionFromKey = (key, pane, fileScope) => {
-  const listPane =
-    pane === 'files' || pane === 'branches' || pane === 'commits';
-  if (listPane && (key === 'left' || key === 'right')) return null;
+  if (LIST_PANES.includes(pane) && (key === 'left' || key === 'right')) {
+    return null;
+  }
   const paneKeys = PANE_KEYS[pane];
   if (paneKeys && paneKeys[key]) return paneKeys[key];
   if (pane === 'files') {
@@ -235,7 +261,11 @@ const actionFromKey = (key, pane, fileScope) => {
 };
 
 const actionKeys = (id) =>
-  ACTIONS[id] ?? BRANCH_ACTIONS[id] ?? COMMIT_ACTIONS[id] ?? [];
+  ACTIONS[id] ??
+  BRANCH_ACTIONS[id] ??
+  COMMIT_ACTIONS[id] ??
+  NPM_ACTIONS[id] ??
+  [];
 
 const actionHot = (id) => ACTION_HOT[id] ?? actionKeys(id)[0];
 
@@ -323,10 +353,12 @@ const promptFromChoices = (choices) =>
   choices.map((choice) => `${choice.lead}${choice.label}`).join('');
 
 module.exports = {
+  LIST_PANES,
   ACTIONS,
   ACTION_IDS,
   BRANCH_ACTIONS,
   COMMIT_ACTIONS,
+  NPM_ACTIONS,
   ACTION_HOT,
   ACTION_LABEL,
   DIFF_DISABLED,
@@ -338,6 +370,7 @@ module.exports = {
   TODO_DISABLED,
   BRANCHES_DISABLED,
   COMMITS_DISABLED,
+  NPM_DISABLED,
   SCROLL,
   PANE_ONLY,
   disabledActions,

package/lib/session/branches.js

@@ -1,8 +1,10 @@
 'use strict';
 
-const { stateView } = require('./accessors.js');
+const accessors = require('./accessors.js');
+const { stateView } = accessors;
 
-const { pickRepoWrite } = require('./ops.js');
+const ops = require('./ops.js');
+const { pickRepoWrite } = ops;
 
 const selectedBranch = (api) => {
   const cursor = api.ui.nav.branchCursor;
@@ -95,12 +97,6 @@ const onCheckoutBranch = (api) => {
   if (!api.ui.status) api.ui.status = done;
 };
 
-const rebaseAsync = (api, onto, done, write) => {
-  const run = (top) => write(top, onto);
-  const after = () => refreshAfterWrite(api, { doneStatus: done });
-  return void api.ui.ops.runBusy('rebasing', done, run, after);
-};
-
 const onRebaseBranch = (api) => {
   if (api.ui.nav.pane !== 'branches') return;
   if (!api.ui.commits.canCommit()) return;
@@ -108,17 +104,9 @@ const onRebaseBranch = (api) => {
   if (!entry || entry.current) return;
   const onto = entry.name;
   const done = `rebased onto ${onto}`;
-  const uiOpen = api.ui.uiOpen;
-  const picked = pickRepoWrite(api.ui.repo, 'rebase', uiOpen);
-  if (picked.async) {
-    return void rebaseAsync(api, onto, done, picked.write);
-  }
-  const ok = api.ui.ops.runRepo(done, (top) => {
-    api.ui.repo.rebase(top, onto);
-  });
-  if (!ok) return;
-  refreshAfterWrite(api);
-  if (!api.ui.status) api.ui.status = done;
+  api.ui.ops.runWrite('rebase', [onto], 'rebasing', done, (extra) =>
+    refreshAfterWrite(api, extra),
+  );
 };
 
 const onDropBranch = (api) => {
@@ -137,29 +125,15 @@ const cancelDropBranch = (api) => {
   api.ui.status = '';
 };
 
-const dropAsync = (api, name, done, write) => {
-  const run = (top) => write(top, name);
-  const after = () => refreshAfterWrite(api, { doneStatus: done });
-  return void api.ui.ops.runBusy('dropping', done, run, after);
-};
-
 const confirmDropBranch = (api) => {
   const name = api.state.dropName;
   api.ui.mode = 'review';
   api.state.dropName = '';
   if (!name) return;
   const done = `dropped ${name}`;
-  const uiOpen = api.ui.uiOpen;
-  const picked = pickRepoWrite(api.ui.repo, 'drop', uiOpen);
-  if (picked.async) {
-    return void dropAsync(api, name, done, picked.write);
-  }
-  const ok = api.ui.ops.runRepo(done, (top) => {
-    api.ui.repo.drop(top, name);
-  });
-  if (!ok) return;
-  refreshAfterWrite(api);
-  if (!api.ui.status) api.ui.status = done;
+  api.ui.ops.runWrite('drop', [name], 'dropping', done, (extra) =>
+    refreshAfterWrite(api, extra),
+  );
 };
 
 const onNewBranch = (api) => {
@@ -201,19 +175,9 @@ const finishCreateBranch = (api) => {
 
 const onPull = (api) => {
   if (!api.ui.commits.canCommit()) return;
-  const repo = api.ui.repo;
-  const picked = pickRepoWrite(repo, 'pull', api.ui.uiOpen);
-  if (picked.async) {
-    const after = () => refreshAfterWrite(api);
-    const write = (top) => picked.write(top);
-    return void api.ui.ops.runBusy('pulling', 'pulled', write, after);
-  }
-  const ok = api.ui.ops.runRepo('pulled', (top) => {
-    repo.pull(top);
-  });
-  if (!ok) return;
-  refreshAfterWrite(api);
-  if (!api.ui.status) api.ui.status = 'pulled';
+  api.ui.ops.runWrite('pull', [], 'pulling', 'pulled', (extra) =>
+    refreshAfterWrite(api, extra),
+  );
 };
 
 const startPush = (api, force) => {

package/lib/session/change-actions.js

@@ -4,7 +4,8 @@ const files = require('../files.js');
 const { listPath, isTodoItem, isTodosEntry, isReadOnlyOrigin } = files;
 const items = require('./items.js');
 const { needsReload, npmBusyKind, sameBlock } = items;
-const { hunkKey } = require('../diff/diff.js');
+const diff = require('../diff/diff.js');
+const { hunkKey } = diff;
 
 const nextUnstageOrigin = (item) => {
   if (item.file.isNew === true) return 'untracked';