reslop 0.2.6 → 0.3.0

package/lib/session/workspace.js

@@ -0,0 +1,416 @@
+'use strict';
+
+const path = require('node:path');
+const { REVIEW_DIR } = require('../common/files.js');
+const { FileIndex, HEAT_MS } = require('../dashboard/tree.js');
+const { UNKNOWN_PATH } = require('../dashboard/watch.js');
+const workspace = require('../dashboard/workspace.js');
+const { emptyDiff, countCommits, readDiffStat, taskStats, pickRun } = workspace;
+const { readNpmSummary } = require('../dashboard/npm.js');
+const { collectReport } = require('../git/deps.js');
+
+const TICK_ID = 'repos';
+const HEAT_TIMER = 'repos-heat';
+
+const freshBag = () => ({
+  files: [],
+  git: false,
+  runs: false,
+  tasks: false,
+  npm: false,
+  activity: false,
+});
+
+const fullBag = () => ({
+  files: [UNKNOWN_PATH],
+  git: true,
+  runs: true,
+  tasks: true,
+  npm: true,
+  activity: false,
+});
+
+const mergeBag = (left, right) => {
+  const base = left ?? freshBag();
+  return {
+    files: [...base.files, ...right.files],
+    git: base.git || right.git,
+    runs: base.runs || right.runs,
+    tasks: base.tasks || right.tasks,
+    npm: base.npm || right.npm,
+    activity: base.activity || right.activity,
+  };
+};
+
+const blankRow = (repo) => ({
+  name: repo.name,
+  dir: repo.dir,
+  index: new FileIndex(repo.dir),
+  bytes: 0,
+  exts: [],
+  tasks: 0,
+  tasksDone: 0,
+  commits: 0,
+  diff: emptyDiff(),
+  run: null,
+  activityAt: 0,
+  filesReady: false,
+  commitsReady: false,
+  diffReady: false,
+  tasksReady: false,
+  runsReady: false,
+  npm: null,
+  npmReady: false,
+  pending: null,
+  running: false,
+});
+
+const readFiles = async (row, bag) => {
+  if (!bag.files.length) return;
+  const unknown = bag.files.includes(UNKNOWN_PATH);
+  if (unknown || !row.index.ready) await row.index.rescan();
+  else await row.index.touch(bag.files);
+  if (!row.index.ready) return;
+  const summary = row.index.summary();
+  row.bytes = summary.total.bytes;
+  row.exts = summary.exts.slice(0, 3);
+  row.filesReady = true;
+};
+
+const readCommits = async (row) => {
+  row.commits = await countCommits(row.dir);
+  row.commitsReady = true;
+};
+
+const readDiff = async (row) => {
+  row.diff = await readDiffStat(row.dir);
+  row.diffReady = true;
+};
+
+const readTasks = (row) => {
+  const stats = taskStats(row.dir);
+  row.tasksDone = stats.done;
+  row.tasks = stats.total;
+  row.tasksReady = true;
+};
+
+const readRuns = (row) => {
+  row.run = pickRun(row.dir);
+  row.runsReady = true;
+};
+
+const reportCount = async (dir, kind) => {
+  const report = await collectReport(dir, kind);
+  return report ? report.size : 0;
+};
+
+const readNpm = async (row) => {
+  const summary = await readNpmSummary(row.dir, row.npm);
+  const [audit, outdated] = await Promise.all([
+    reportCount(row.dir, 'audit'),
+    reportCount(row.dir, 'outdated'),
+  ]);
+  row.npm = { ...summary, audit, outdated };
+  row.npmReady = true;
+};
+
+const toTile = (row) => ({
+  id: row.name,
+  name: row.name,
+  bytes: row.bytes,
+  exts: row.exts,
+  tasks: row.tasks,
+  tasksDone: row.tasksDone,
+  commits: row.commits,
+  diff: row.diff,
+  run: row.run,
+  activityAt: row.activityAt,
+  filesReady: row.filesReady,
+  commitsReady: row.commitsReady,
+  diffReady: row.diffReady,
+  tasksReady: row.tasksReady,
+  runsReady: row.runsReady,
+  npm: row.npm,
+  npmReady: row.npmReady,
+});
+
+const rowBusy = (row) => {
+  if (!row.filesReady || !row.commitsReady) return true;
+  if (!row.diffReady || !row.tasksReady) return true;
+  return !row.runsReady || !row.npmReady;
+};
+
+const classifyRest = (rest) => {
+  const bag = freshBag();
+  if (!rest) {
+    bag.files.push(UNKNOWN_PATH);
+    bag.git = true;
+    bag.runs = true;
+    bag.tasks = true;
+    bag.npm = true;
+    bag.activity = true;
+    return bag;
+  }
+  if (
+    rest === 'package.json' ||
+    rest === 'package-lock.json' ||
+    rest === 'node_modules/.package-lock.json'
+  ) {
+    bag.npm = true;
+  }
+  if (rest === '.git' || rest.startsWith('.git/')) {
+    bag.git = true;
+    return bag;
+  }
+  if (rest === '.log' || rest.startsWith('.log/')) {
+    bag.runs = true;
+    return bag;
+  }
+  if (rest === REVIEW_DIR || rest.startsWith(`${REVIEW_DIR}/`)) {
+    bag.tasks = true;
+    return bag;
+  }
+  bag.files.push(rest);
+  bag.activity = true;
+  return bag;
+};
+
+class Workspace {
+  constructor(ui) {
+    this.ui = ui;
+    this.epoch = 0;
+    this.reset();
+  }
+
+  reset() {
+    this.stop();
+    this.rows = [];
+    this.byName = new Map();
+    this.cursor = 0;
+    this.cols = 1;
+  }
+
+  seed() {
+    const info = this.ui.workspaceInfo;
+    const repos = info ? info.repos : [];
+    this.rows = repos.map(blankRow);
+    this.byName = new Map(this.rows.map((row) => [row.name, row]));
+    if (this.cursor >= this.rows.length) this.cursor = 0;
+  }
+
+  stale(epoch) {
+    return epoch !== this.epoch || !this.active;
+  }
+
+  publish(epoch) {
+    if (this.stale(epoch)) return;
+    this.afterDraw();
+    if (this.ui.uiOpen && this.ui.nav.pane === 'repos') this.ui.paint();
+  }
+
+  async settle(epoch, read) {
+    await read();
+    this.publish(epoch);
+  }
+
+  async apply(row, bag, epoch) {
+    if (bag.activity) row.activityAt = Date.now();
+    const jobs = [];
+    if (bag.files.length) {
+      jobs.push(this.settle(epoch, () => readFiles(row, bag)));
+    }
+    if (bag.git) {
+      jobs.push(this.settle(epoch, () => readCommits(row)));
+      jobs.push(this.settle(epoch, () => readDiff(row)));
+    }
+    if (bag.tasks) jobs.push(this.settle(epoch, () => readTasks(row)));
+    if (bag.runs) jobs.push(this.settle(epoch, () => readRuns(row)));
+    if (bag.npm) jobs.push(this.settle(epoch, () => readNpm(row)));
+    await Promise.all(jobs);
+  }
+
+  async pump(row) {
+    row.running = true;
+    while (row.pending && this.active) {
+      const bag = row.pending;
+      const epoch = this.epoch;
+      row.pending = null;
+      try {
+        await this.apply(row, bag, epoch);
+      } catch {
+        // keep the previous snapshot until the next event
+      }
+      if (this.stale(epoch)) break;
+      this.afterDraw();
+      if (this.ui.uiOpen && this.ui.nav.pane === 'repos') this.ui.paint();
+    }
+    row.running = false;
+    if (row.pending && this.active) {
+      void this.pump(row);
+      return;
+    }
+    this.afterDraw();
+    if (this.ui.uiOpen && this.ui.nav.pane === 'repos') this.ui.paint();
+  }
+
+  kick(row, bag) {
+    if (!row || !this.active) return;
+    if (bag.activity) row.activityAt = Date.now();
+    row.pending = mergeBag(row.pending, bag);
+    if (row.running) return;
+    void this.pump(row);
+  }
+
+  requestAll() {
+    for (const row of this.rows) this.kick(row, fullBag());
+  }
+
+  notePaths(paths) {
+    if (!this.active) return;
+    for (const rel of paths) {
+      if (rel === UNKNOWN_PATH) return void this.requestAll();
+    }
+    const found = new Map();
+    for (const rel of paths) {
+      const slash = rel.indexOf('/');
+      const name = slash < 0 ? rel : rel.slice(0, slash);
+      const rest = slash < 0 ? '' : rel.slice(slash + 1);
+      const row = this.byName.get(name);
+      if (!row) continue;
+      found.set(name, mergeBag(found.get(name), classifyRest(rest)));
+    }
+    for (const [name, bag] of found) this.kick(this.byName.get(name), bag);
+    if (found.size) {
+      this.afterDraw();
+      if (this.ui.uiOpen) this.ui.paint();
+    }
+  }
+
+  start() {
+    if (this.active) return;
+    this.active = true;
+    if (!this.rows.length) this.seed();
+    this.requestAll();
+  }
+
+  stop() {
+    this.epoch += 1;
+    this.active = false;
+    this.cancelTimers();
+  }
+
+  cancelTimers() {
+    const { progress, term } = this.ui;
+    if (!progress || !term) return;
+    progress.stop(TICK_ID);
+    term.cancel(HEAT_TIMER);
+  }
+
+  hotUntil() {
+    let until = 0;
+    for (const row of this.rows) {
+      until = Math.max(until, row.activityAt + HEAT_MS);
+    }
+    return until;
+  }
+
+  afterDraw() {
+    if (!this.active) return;
+    const visible = this.ui.uiOpen && this.ui.nav.pane === 'repos';
+    if (!visible) return void this.cancelTimers();
+    const now = Date.now();
+    const until = this.hotUntil();
+    const hot = now < until;
+    const running = this.rows.some((row) => row.run?.status === 'running');
+    const loading = this.rows.some((row) => rowBusy(row));
+    const { progress, term } = this.ui;
+    if (running || hot || loading) progress.start(TICK_ID);
+    else progress.stop(TICK_ID);
+    if (!hot) return;
+    term.later(
+      HEAT_TIMER,
+      () => {
+        if (this.ui.nav.pane === 'repos') this.ui.paint();
+      },
+      until - now + 20,
+    );
+  }
+
+  view() {
+    return {
+      now: Date.now(),
+      frame: this.ui.progressFrame,
+      cursor: this.cursor,
+      tiles: this.rows.map(toTile),
+    };
+  }
+
+  move(dx, dy) {
+    const count = this.rows.length;
+    if (!count) return;
+    const cols = Math.max(1, this.cols || 1);
+    const next = this.cursor + dx + dy * cols;
+    if (next < 0 || next >= count) return;
+    this.cursor = next;
+    if (this.ui.uiOpen) this.ui.paint();
+  }
+
+  async switchTo(row) {
+    const ui = this.ui;
+    ui.flushReview();
+    this.stop();
+    ui.retarget({ cwd: row.dir, repoName: row.name, pane: 'dashboard' });
+    try {
+      await ui.ensureRepo();
+    } catch (error) {
+      ui.status = error instanceof Error ? error.message : `${error}`;
+      return { loading: this.show() };
+    }
+    const loading = ui.openLoad();
+    if (ui.uiOpen) {
+      ui.lifecycle.startWatch();
+      ui.dashboard.start();
+      ui.paint();
+    }
+    return { loading };
+  }
+
+  async enter(name) {
+    const row = this.byName.get(name);
+    const ui = this.ui;
+    if (!row || ui.mode !== 'review') return;
+    const opened = await ui.ops.hold(this.switchTo(row));
+    if (opened) await opened.loading;
+  }
+
+  openSelected() {
+    const row = this.rows[this.cursor];
+    if (!row) return Promise.resolve();
+    return this.enter(row.name);
+  }
+
+  openAt(id) {
+    const index = this.rows.findIndex((row) => row.name === id);
+    if (index < 0) return Promise.resolve();
+    this.cursor = index;
+    return this.openSelected();
+  }
+
+  show() {
+    const ui = this.ui;
+    if (!ui.workspaceRoot) return Promise.resolve();
+    ui.flushReview();
+    const root = ui.workspaceRoot;
+    const repoName = path.basename(root);
+    ui.retarget({ cwd: root, top: root, repoName, pane: 'repos' });
+    ui.loader.didLoad = true;
+    this.start();
+    if (ui.uiOpen) {
+      ui.lifecycle.startWatch();
+      ui.paint();
+    }
+    return Promise.resolve();
+  }
+}
+
+module.exports = { Workspace };

package/lib/{capabilities.js → source/capabilities.js}

@@ -2,7 +2,6 @@
 
 const READ_METHODS = [
   'load',
-  'loadAsync',
   'loadExtras',
   'toplevel',
   'resolveRev',
@@ -12,7 +11,6 @@ const READ_METHODS = [
 
 const CHANGE_METHODS = [
   'add',
-  'addAsync',
   'unstage',
   'revert',
   'revertFile',
@@ -23,7 +21,7 @@ const CHANGE_METHODS = [
 
 const BRANCH_METHODS = [
   'commit',
-  'commitAsync',
+  'updateCommit',
   'hasStaged',
   'lastMessage',
   'commitMessage',
@@ -31,23 +29,14 @@ const BRANCH_METHODS = [
   'listCommits',
   'currentBranch',
   'checkout',
-  'checkoutAsync',
   'createBranch',
-  'createBranchAsync',
   'rebase',
-  'rebaseAsync',
   'drop',
-  'dropAsync',
   'dropCommit',
-  'dropCommitAsync',
   'applyFixup',
-  'applyFixupAsync',
   'reword',
-  'rewordAsync',
   'pull',
-  'pullAsync',
   'push',
-  'pushAsync',
 ];
 
 const VIEW_CAPS = { read: true, changes: false, branches: false, review: true };
@@ -57,6 +46,8 @@ const SOURCE_CAPS = {
   commit: VIEW_CAPS,
   pr: VIEW_CAPS,
   mr: VIEW_CAPS,
+  issue: VIEW_CAPS,
+  'gl-issue': VIEW_CAPS,
   readonly: VIEW_CAPS,
 };
 

package/lib/{github.js → source/github.js}

@@ -1,13 +1,12 @@
 'use strict';
 
-const metautil = require('metautil');
-const { isHashObject } = metautil;
-const files = require('./files.js');
-const { isPathInScope } = files;
+const { isHashObject } = require('metautil');
+const { isPathInScope } = require('../common/files.js');
+const { resource } = require('../common/utilities.js');
 const remote = require('./remote.js');
 const { RemoteClient, isAbortError, listUrl, parseLinkNext } = remote;
 const { commentBody, importedTodo, noteFromLocation } = remote;
-const { splitNotes, loadChange } = remote;
+const { splitNotes, loadChange, stateIs, loadIssue } = remote;
 
 const GITHUB_API = 'https://api.github.com';
 const API_VERSION = '2022-11-28';
@@ -17,14 +16,9 @@ const DIFF_ACCEPT = 'application/vnd.github.diff';
 const PR_TODO_FILE = 'pull request';
 const IMPORT_HOST = 'github';
 const GRAPHQL_URL = `${GITHUB_API}/graphql`;
-const REVIEW_THREADS_QUERY =
-  'query($owner: String!, $name: String!, $number: Int!, $after: String) {' +
-  ' repository(owner: $owner, name: $name) {' +
-  ' pullRequest(number: $number) {' +
-  ' reviewThreads(first: 100, after: $after) {' +
-  ' pageInfo { hasNextPage endCursor }' +
-  ' nodes { isResolved comments(first: 100) { nodes { databaseId } } }' +
-  ' } } } }';
+const REVIEW_THREADS_QUERY = resource(__dirname, 'review-threads.graphql')
+  .replace(/\s+/g, ' ')
+  .trim();
 
 const GITHUB_PR_RE = new RegExp(
   String.raw`^(?:https?://)?(?:www\.)?github\.com/` +
@@ -35,18 +29,41 @@ const GITHUB_PR_RE = new RegExp(
   'i',
 );
 
-const parseGithubPrUrl = (text) => {
+const GITHUB_ISSUE_RE = new RegExp(
+  String.raw`^(?:https?://)?(?:www\.)?github\.com/` +
+    String.raw`([^/?#]+)/([^/?#]+)/issues/(\d+)` +
+    String.raw`/?(?:[?#].*)?$`,
+  'i',
+);
+
+const GITHUB_ISSUE_LIST_RE = new RegExp(
+  String.raw`^(?:https?://)?(?:www\.)?github\.com/` +
+    String.raw`([^/?#]+)/([^/?#]+?)(?:\.git)?` +
+    String.raw`(?:/issues)?` +
+    String.raw`/?(?:[?#].*)?$`,
+  'i',
+);
+
+const parseGithubUrl = (text, pattern) => {
   if (typeof text !== 'string' || !text) return null;
-  const match = GITHUB_PR_RE.exec(text.trim());
+  const match = pattern.exec(text.trim());
   if (!match) return null;
   const owner = match[1];
   const repo = match[2].replace(/\.git$/i, '');
+  if (!owner || !repo) return null;
+  if (!match[3]) return { owner, repo, list: true };
   const number = parseInt(match[3], 10);
-  const hasNumber = Number.isFinite(number) && number >= 1;
-  if (!owner || !repo || !hasNumber) return null;
+  if (!Number.isFinite(number) || number < 1) return null;
   return { owner, repo, number };
 };
 
+const parseGithubPrUrl = (text) => parseGithubUrl(text, GITHUB_PR_RE);
+
+const parseGithubIssueUrl = (text) => parseGithubUrl(text, GITHUB_ISSUE_RE);
+
+const parseGithubIssueListUrl = (text) =>
+  parseGithubUrl(text, GITHUB_ISSUE_LIST_RE);
+
 const githubToken = (env) => {
   const from = env ?? process.env;
   return from.GITHUB_TOKEN || from.GH_TOKEN || '';
@@ -69,12 +86,13 @@ const client = new RemoteClient({
   nextPage: parseLinkNext,
 });
 
-const prApiUrl = (pr) => {
-  const owner = encodeURIComponent(pr.owner);
-  const repo = encodeURIComponent(pr.repo);
-  return `${GITHUB_API}/repos/${owner}/${repo}/pulls/${pr.number}`;
+const repositoryApiUrl = ({ owner, repo }) => {
+  const name = `${encodeURIComponent(owner)}/${encodeURIComponent(repo)}`;
+  return `${GITHUB_API}/repos/${name}`;
 };
 
+const prApiUrl = (pr) => `${repositoryApiUrl(pr)}/pulls/${pr.number}`;
+
 const loginOf = (user) => user?.login || '';
 
 const toChange = (pr, data) => {
@@ -131,12 +149,15 @@ const discussionToNotes = (discussion, items, paths = []) => {
   const comments = discussion.reviewComments ?? [];
   const reviews = discussion.reviews ?? [];
   const issueComments = discussion.issueComments ?? [];
-  return splitNotes([
-    ...comments.map((comment) =>
-      reviewCommentToNote(comment, items, resolvedById, paths),
-    ),
-    ...[...reviews, ...issueComments].map((record) => summaryToTodo(record)),
-  ]);
+  const reviewNote = (comment) => {
+    const note = reviewCommentToNote(comment, items, resolvedById, paths);
+    return note;
+  };
+  const reviewNotes = comments.map(reviewNote);
+  const summaries = [...reviews, ...issueComments];
+  const summaryNotes = summaries.map(summaryToTodo);
+  const notes = [...reviewNotes, ...summaryNotes];
+  return splitNotes(notes);
 };
 
 const requestThreads = async (variables, options) => {
@@ -184,12 +205,15 @@ const loadResolvedById = async (pr, options) => {
 
 const loadDiscussion = async (pr, options) => {
   const pull = prApiUrl(pr);
-  const issue = pull.replace('/pulls/', '/issues/');
+  const issue = `${repositoryApiUrl(pr)}/issues/${pr.number}`;
   const list = (url) => client.list(listUrl(url), options);
-  const reviewComments = await list(`${pull}/comments`);
-  const reviews = await list(`${pull}/reviews`);
-  const issueComments = await list(`${issue}/comments`);
-  const resolvedById = await loadResolvedById(pr, options);
+  const [reviewComments, reviews, issueComments, resolvedById] =
+    await Promise.all([
+      list(`${pull}/comments`),
+      list(`${pull}/reviews`),
+      list(`${issue}/comments`),
+      loadResolvedById(pr, options),
+    ]);
   return { reviewComments, reviews, issueComments, resolvedById };
 };
 
@@ -204,10 +228,56 @@ const loadPullRequest = (pr, options = {}) =>
     discussionToNotes,
   });
 
+const issueSite = (issue) => {
+  const repository = `${issue.owner}/${issue.repo}`;
+  return {
+    repository,
+    id: `github.com/${repository}/issues`,
+    page: `https://github.com/${repository}/issues`,
+  };
+};
+
+const readIssue = (data) => ({
+  number: data.number,
+  title: data.title,
+  body: data.body,
+  author: loginOf(data.user),
+  state: data.state,
+  url: data['html_url'],
+  comments: data.comments,
+});
+
+const readIssueComment = (comment) => ({
+  reviewer: loginOf(comment.user),
+  body: comment.body,
+});
+
+const isOpenIssue = (data) => {
+  if (!isHashObject(data)) return false;
+  if (isHashObject(data['pull_request'])) return false;
+  return stateIs(data.state, 'open');
+};
+
+const loadGithubIssue = async (issue, options = {}) =>
+  loadIssue(issue, options, {
+    client,
+    host: IMPORT_HOST,
+    site: issueSite(issue),
+    issuesUrl: `${repositoryApiUrl(issue)}/issues`,
+    openState: 'open',
+    comments: 'comments',
+    isOpen: isOpenIssue,
+    readIssue,
+    readComment: readIssueComment,
+  });
+
 module.exports = {
   parseGithubPrUrl,
+  parseGithubIssueUrl,
+  parseGithubIssueListUrl,
   githubToken,
   prApiUrl,
   discussionToNotes,
   loadPullRequest,
+  loadGithubIssue,
 };