reslop 0.2.6 → 0.3.0

package/lib/session/navigation.js

@@ -1,9 +1,8 @@
 'use strict';
 
-const files = require('../files.js');
+const files = require('../common/files.js');
 const { listPath, isTaskItem, isTasksEntry, TASKS_FILE } = files;
-const actions = require('./actions.js');
-const { LIST_PANES } = actions;
+const { LIST_PANES } = require('../input/actions.js');
 
 const freshListScroll = () =>
   Object.fromEntries(LIST_PANES.map((pane) => [pane, 0]));
@@ -20,6 +19,8 @@ class Navigation {
     this.branchCursor = 0;
     this.commitCursor = 0;
     this.npmCursor = 0;
+    this.packagesCursor = 0;
+    this.agentCursor = 0;
     this.scroll = 0;
     this.listScrollByPane = freshListScroll();
     this.reviewPath = null;
@@ -28,9 +29,12 @@ class Navigation {
     this.selection = null;
     this.mouseAnchor = null;
     this.pendingClick = null;
+    this.scrollDrag = null;
     this.lastClick = null;
     this.tasksOpen = false;
     this.tasksFocus = 0;
+    this.find = null;
+    this.import = null;
   }
 
   clampIndex(length) {
@@ -96,6 +100,7 @@ class Navigation {
     this.selection = null;
     this.mouseAnchor = null;
     this.pendingClick = null;
+    this.scrollDrag = null;
   }
 
   get listScroll() {

package/lib/session/npm/history.js

@@ -0,0 +1,249 @@
+'use strict';
+
+const { stripAnsi } = require('../../term/ansi.js');
+const { buildDocument } = require('../../report/parse.js');
+const report = require('../../report/render.js');
+const { renderDocument, renderReport } = report;
+const runStore = require('../../runs/runs.js');
+const { Tracker, summarizeDocument } = runStore;
+const { runName } = require('../../dashboard/model.js');
+const { reduceOutput } = require('../../runs/output.js');
+const { trimText, pad2 } = require('../../common/utilities.js');
+
+const TESTS_RE = /^(?:TAP version \d+|\s*(?:not )?ok\b|[ℹi]\s+tests\s+\d+)/m;
+
+const filteredOutput = (raw, root, status, rawFile) => {
+  const text = stripAnsi(`${raw ?? ''}`);
+  if (status === '' || !TESTS_RE.test(text)) {
+    const output = reduceOutput(raw, root, status);
+    return { output, log: output, result: null };
+  }
+  const doc = buildDocument(raw, '', root, status, 'test');
+  const result = summarizeDocument(doc);
+  const output = renderReport(doc);
+  const log = renderDocument(doc, rawFile);
+  return { output, log, result };
+};
+
+const runLabel = (entry) =>
+  entry.kind === 'bin' ? `npm exec ${entry.name}` : `npm run ${entry.name}`;
+
+const historyMark = (run) => {
+  if (run.status === 'running') return 'run';
+  if (run.status === 'stopped') return 'stop';
+  if (run.exit === 0 || run.exit === '0') return 'pass';
+  return 'fail';
+};
+
+const historyCounts = (run) => {
+  const result = run.result;
+  if (result && typeof result.tests === 'number') {
+    const fail = result.failed ?? 0;
+    const ok = result.passed ?? Math.max(0, result.tests - fail);
+    return { done: result.tests, ok, fail, total: result.tests };
+  }
+  const progress = run.progress;
+  if (!progress) return null;
+  const ok = progress.done ?? 0;
+  const fail = progress.failed ?? 0;
+  if (!ok && !fail && !(progress.expected > 0)) return null;
+  const total = progress.expected > 0 ? progress.expected : null;
+  return { done: ok + fail, ok, fail, total };
+};
+
+const countText = (value) => (typeof value === 'number' ? `${value}` : '');
+
+const historyExit = (run, counts) => {
+  if (counts || run.status !== 'exited') return '';
+  if (run.exit === '' || run.exit === null || run.exit === undefined) return '';
+  return `exit ${run.exit}`;
+};
+
+const earlierTotal = (list, run) => {
+  let best = 0;
+  let at = -1;
+  for (const item of list) {
+    if (item === run || item.name !== run.name) continue;
+    if (item.status === 'running') continue;
+    const counts = historyCounts(item);
+    if (!counts || typeof counts.total !== 'number') continue;
+    const started = item.startedAt || 0;
+    if (started < at) continue;
+    at = started;
+    best = counts.total;
+  }
+  return best;
+};
+
+const noteTests = (run, list, text) => {
+  const plain = stripAnsi(`${text ?? ''}`);
+  if (!TESTS_RE.test(plain)) return;
+  const tracker = new Tracker();
+  tracker.feed(plain);
+  if (!Object.hasOwn(run, 'expected')) run.expected = earlierTotal(list, run);
+  run.progress = {
+    done: tracker.progress.done,
+    failed: tracker.progress.failed,
+    expected: run.expected,
+  };
+};
+
+const RUN_KEEP = 50;
+
+const LOG_GAP_MS = 2000;
+
+const RESLOP_RUN = /^reslop(?:\.js)?\s+t\s+--\s+/;
+
+const RESLOP_T = /reslop(?:\.js)?\s+t\s+--/;
+
+const launchedReslop = (run) => {
+  if (run.externalId) return false;
+  const command = `${run.command ?? ''}`;
+  return RESLOP_T.test(command);
+};
+
+const historyName = (run) => {
+  const script = trimText(run.name);
+  if (script) return script;
+  return trimText(run.command).replace(RESLOP_RUN, '');
+};
+
+const sameWindow = (left, right) => {
+  const start = Number(left.startedAt) || 0;
+  const end = Number(left.endedAt) || start;
+  const at = Number(right.startedAt) || 0;
+  const done = Number(right.endedAt) || at;
+  return done >= start - LOG_GAP_MS && at <= end + LOG_GAP_MS;
+};
+
+const logBase = (name) => {
+  const file = `${name ?? ''}`;
+  if (!file || file.includes('/') || file.includes('\\')) return '';
+  return file;
+};
+
+const externalStatus = (record) => {
+  if (record.status === 'running') return 'running';
+  if (record.status === 'aborted') return 'stopped';
+  return 'exited';
+};
+
+const externalExit = (record) => {
+  if (record.status === 'running' || record.status === 'aborted') return '';
+  if (record.exit === null || record.exit === undefined) return '';
+  return record.exit;
+};
+
+const progressCount = (progress, key) => {
+  if (!progress || typeof progress[key] !== 'number') return 0;
+  return progress[key];
+};
+
+const progressSame = (left, right) => {
+  const done = progressCount(left, 'done') === progressCount(right, 'done');
+  const leftFailed = progressCount(left, 'failed');
+  const rightFailed = progressCount(right, 'failed');
+  const failed = leftFailed === rightFailed;
+  const leftExpected = progressCount(left, 'expected');
+  const rightExpected = progressCount(right, 'expected');
+  const expected = leftExpected === rightExpected;
+  return done && failed && expected;
+};
+
+const resultSame = (left, right) => {
+  if (!left && !right) return true;
+  if (!left || !right) return false;
+  return (
+    left.tests === right.tests &&
+    left.passed === right.passed &&
+    left.failed === right.failed &&
+    left.errors === right.errors
+  );
+};
+
+const applyExternal = (run, record) => {
+  const status = externalStatus(record);
+  const exit = externalExit(record);
+  const endedAt = Number(record.endedAt) || 0;
+  const progress = record.progress ?? null;
+  const result = record.result ?? null;
+  const same =
+    run.status === status &&
+    run.exit === exit &&
+    (run.endedAt || 0) === endedAt &&
+    progressSame(run.progress, progress) &&
+    resultSame(run.result, result);
+  if (same) return false;
+  run.status = status;
+  run.exit = exit;
+  run.endedAt = endedAt;
+  run.progress = progress;
+  run.result = result;
+  return true;
+};
+
+const recordedItem = (record) => {
+  const script = trimText(record.script);
+  const command = trimText(record.command);
+  const name = runName({ command, script }).replace(RESLOP_RUN, '');
+  return {
+    name,
+    kind: script ? 'script' : 'command',
+    command,
+    status: externalStatus(record),
+    exit: externalExit(record),
+    startedAt: Number(record.startedAt) || 0,
+    endedAt: Number(record.endedAt) || 0,
+    logName: logBase(record.log),
+    rawName: logBase(record.raw),
+    externalId: `${record.id ?? ''}`,
+    result: record.result ?? null,
+    progress: record.progress ?? null,
+  };
+};
+
+const whenLabel = (ms) => {
+  if (!ms) return '';
+  const date = new Date(ms);
+  const hh = pad2(date.getHours());
+  const mm = pad2(date.getMinutes());
+  const time = `${hh}:${mm}`;
+  const today = new Date();
+  const sameDay =
+    date.getFullYear() === today.getFullYear() &&
+    date.getMonth() === today.getMonth() &&
+    date.getDate() === today.getDate();
+  if (sameDay) return time;
+  const month = pad2(date.getMonth() + 1);
+  const day = pad2(date.getDate());
+  return `${month}-${day} ${time}`;
+};
+
+const elapsedText = (run, now) => {
+  const end = run.endedAt || now;
+  const ms = Math.max(0, end - (run.startedAt || end));
+  const sec = Math.round(ms / 1000);
+  if (sec < 60) return `${sec}s`;
+  const min = Math.floor(sec / 60);
+  const rest = sec % 60;
+  return `${min}m${pad2(rest)}s`;
+};
+
+module.exports = {
+  filteredOutput,
+  runLabel,
+  historyMark,
+  historyCounts,
+  countText,
+  historyExit,
+  noteTests,
+  RUN_KEEP,
+  launchedReslop,
+  historyName,
+  sameWindow,
+  logBase,
+  applyExternal,
+  recordedItem,
+  whenLabel,
+  elapsedText,
+};