reslop 0.2.6 → 0.3.0

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

@@ -1,12 +1,11 @@
 '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 remote = require('./remote.js');
 const { RemoteClient, listUrl, parseNextPage, commentBody } = remote;
 const { importedTodo, noteFromLocation, splitNotes, loadChange } = remote;
+const { stateIs, loadIssue } = remote;
 
 const USER_AGENT = 'reslop';
 const JSON_ACCEPT = 'application/json';
@@ -24,9 +23,16 @@ const GITLAB_MR_RE = new RegExp(
   'i',
 );
 
-const parseGitlabMrUrl = (text) => {
+const GITLAB_ISSUE_RE = new RegExp(
+  String.raw`^(?:(https?)://)?(?:www\.)?([^/?#]+)/` +
+    String.raw`(.+?)(?:/-)?/issues/(\d+)` +
+    String.raw`/?(?:[?#].*)?$`,
+  'i',
+);
+
+const parseGitlabUrl = (text, pattern) => {
   if (typeof text !== 'string' || !text) return null;
-  const match = GITLAB_MR_RE.exec(text.trim());
+  const match = pattern.exec(text.trim());
   if (!match) return null;
   const scheme = (match[1] || 'https').toLowerCase();
   const host = match[2];
@@ -37,6 +43,35 @@ const parseGitlabMrUrl = (text) => {
   return { host, project, number, origin: `${scheme}://${host}` };
 };
 
+const GITLAB_HOST_RE = new RegExp(
+  String.raw`^(?:(https?)://)?(?:www\.)?([^/?#]+\.[^/?#]+)/([^?#]+)`,
+  'i',
+);
+
+const parseGitlabMrUrl = (text) => parseGitlabUrl(text, GITLAB_MR_RE);
+
+const parseGitlabIssueUrl = (text) => {
+  const issue = parseGitlabUrl(text, GITLAB_ISSUE_RE);
+  return issue?.host.toLowerCase() === 'github.com' ? null : issue;
+};
+
+const parseGitlabIssueListUrl = (text) => {
+  if (typeof text !== 'string' || !text) return null;
+  const match = GITLAB_HOST_RE.exec(text.trim());
+  if (!match) return null;
+  const scheme = (match[1] || 'https').toLowerCase();
+  const host = match[2];
+  if (!host || host.toLowerCase() === 'github.com') return null;
+  let path = match[3].replace(/\/+$/, '');
+  if (/\/issues\/\d+/.test(path)) return null;
+  const listed = /(?:\/-)?\/issues$/.test(path);
+  if (listed) path = path.replace(/(?:\/-)?\/issues$/, '');
+  else if (path.includes('/-/')) return null;
+  path = path.replace(/\.git$/i, '');
+  if (!path.includes('/')) return null;
+  return { host, project: path, origin: `${scheme}://${host}`, list: true };
+};
+
 const gitlabToken = (env) => {
   const from = env ?? process.env;
   return from.GITLAB_TOKEN || from.GL_TOKEN || '';
@@ -57,10 +92,10 @@ const client = new RemoteClient({
   limitStatus: 429,
 });
 
-const mrApiUrl = (mr) => {
-  const project = encodeURIComponent(mr.project);
-  return `${mr.origin}/api/v4/projects/${project}/merge_requests/${mr.number}`;
-};
+const projectApiUrl = (ref) =>
+  `${ref.origin}/api/v4/projects/${encodeURIComponent(ref.project)}`;
+
+const mrApiUrl = (mr) => `${projectApiUrl(mr)}/merge_requests/${mr.number}`;
 
 const usernameOf = (user) => user?.username || '';
 
@@ -133,6 +168,45 @@ const discussionToNotes = (discussions, items, paths = []) => {
 const loadDiscussion = (mr, options) =>
   client.list(listUrl(`${mrApiUrl(mr)}/discussions`), options);
 
+const issueSite = (issue) => ({
+  repository: issue.project,
+  id: `${issue.host}/${issue.project}/issues`,
+  page: `${issue.origin}/${issue.project}/-/issues`,
+});
+
+const readIssue = (data) => ({
+  number: data.iid,
+  title: data.title,
+  body: data.description,
+  author: usernameOf(data.author),
+  state: data.state,
+  url: data.web_url,
+  comments: data.user_notes_count,
+});
+
+const readIssueNote = (note) => {
+  if (!isHashObject(note) || note.system === true) return null;
+  return { reviewer: usernameOf(note.author), body: note.body };
+};
+
+const isOpenIssue = (data) => {
+  if (!isHashObject(data)) return false;
+  return stateIs(data.state, 'opened');
+};
+
+const loadGitlabIssue = async (issue, options = {}) =>
+  loadIssue(issue, options, {
+    client,
+    host: IMPORT_HOST,
+    site: issueSite(issue),
+    issuesUrl: `${projectApiUrl(issue)}/issues`,
+    openState: 'opened',
+    comments: 'notes',
+    isOpen: isOpenIssue,
+    readIssue,
+    readComment: readIssueNote,
+  });
+
 const loadMergeRequest = (mr, options = {}) => {
   const url = mrApiUrl(mr);
   return loadChange(mr, options, {
@@ -149,8 +223,11 @@ const loadMergeRequest = (mr, options = {}) => {
 
 module.exports = {
   parseGitlabMrUrl,
+  parseGitlabIssueUrl,
+  parseGitlabIssueListUrl,
   gitlabToken,
   mrApiUrl,
   discussionToNotes,
+  loadGitlabIssue,
   loadMergeRequest,
 };

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

@@ -1,15 +1,10 @@
 'use strict';
 
-const metautil = require('metautil');
-const { delay, jsonParse, isHashObject } = metautil;
-const utilities = require('./utilities.js');
-const { oneLine } = utilities;
-const files = require('./files.js');
-const { itemPath, isPathInScope } = files;
-const diff = require('./diff/diff.js');
-const { parseDiff, itemsFromFiles, isCtxType } = diff;
-const deps = require('./deps.js');
-const { foldDepItems } = deps;
+const { delay, jsonParse, isHashObject } = require('metautil');
+const { oneLine, trimText } = require('../common/utilities.js');
+const { itemPath, isPathInScope, ISSUE_FILE } = require('../common/files.js');
+const { parseDiff, itemsFromFiles, isCtxType } = require('../diff/diff.js');
+const { foldDepItems } = require('../deps/deps.js');
 
 const RETRY_ATTEMPTS = 3;
 const RETRY_DELAY_MS = 200;
@@ -62,19 +57,18 @@ class RemoteClient {
     throw this.error('PARSE', `${this.name} API: invalid ${label}`);
   }
 
-  httpError(status, body, token) {
+  httpError(status, body, token, subject = this.subject) {
     const { name, prefix } = this;
-    const text = `${body ?? ''}`.trim();
+    const text = trimText(body);
     const parsed = jsonParse(text);
     const fields = this.errorFields;
     const field = fields.find((key) => typeof parsed?.[key] === 'string');
-    const message =
-      isHashObject(parsed) && field ? parsed[field] : oneLine(text);
+    const fromField = isHashObject(parsed) && field;
+    const message = fromField ? parsed[field] : oneLine(text);
     if (status === 404) {
-      const hint = token
-        ? ''
-        : ` (set ${prefix}_TOKEN for private repositories)`;
-      const notFound = `${name} ${this.subject} not found${hint}`;
+      let hint = '';
+      if (!token) hint = ` (set ${prefix}_TOKEN for private repositories)`;
+      const notFound = `${name} ${subject} not found${hint}`;
       return this.error('NOT_FOUND', notFound, { status });
     }
     if (status === 401) {
@@ -101,18 +95,22 @@ class RemoteClient {
     const init = { method: options.method || 'GET', headers };
     if (options.body !== undefined) init.body = options.body;
     if (signal) init.signal = signal;
-    let response;
-    try {
-      response = await options.fetch(url, init);
-    } catch (cause) {
-      if (isAbortError(cause, signal)) throw cause;
-      const detail = oneLine(cause && cause.message);
-      const suffix = detail ? `: ${detail}` : '';
-      const message = `${this.name} request failed${suffix}`;
-      throw this.error('NETWORK', message, { cause });
-    }
+    const load = async () => {
+      try {
+        return await options.fetch(url, init);
+      } catch (cause) {
+        if (isAbortError(cause, signal)) throw cause;
+        const detail = oneLine(cause && cause.message);
+        const suffix = detail ? `: ${detail}` : '';
+        const message = `${this.name} request failed${suffix}`;
+        throw this.error('NETWORK', message, { cause });
+      }
+    };
+    const response = await load();
     const text = await response.text();
-    if (!response.ok) throw this.httpError(response.status, text, token);
+    if (!response.ok) {
+      throw this.httpError(response.status, text, token, options.subject);
+    }
     return { body: text, headers: response.headers };
   }
 
@@ -183,7 +181,14 @@ const listUrl = (base) => {
   return url.toString();
 };
 
-const commentBody = (value) => `${value ?? ''}`.trim();
+const commentBody = (value) => trimText(value);
+
+const issueText = (title, body) => {
+  const head = trimText(title);
+  const rest = commentBody(body);
+  if (head && rest) return `${head}\n\n${rest}`;
+  return head || rest;
+};
 
 const sideLineNumber = (type, oldNo, newNo, side) => {
   if (side === 'LEFT') return type === 'add' ? 0 : oldNo;
@@ -228,6 +233,21 @@ const importedTodo = (file, entry, host) => ({
   done: entry.resolved === true,
 });
 
+const issueTodoText = (entry, host) => {
+  const reviewer = entry.reviewer || 'unknown';
+  const body = `@${reviewer} at ${host}: ${commentBody(entry.body)}`;
+  const url = trimText(entry.url);
+  if (!url) return body;
+  return `${body}\nIssue: ${url}`;
+};
+
+const issueTodo = (entry, host) => ({
+  kind: 'todo',
+  file: ISSUE_FILE,
+  text: issueTodoText(entry, host),
+  done: entry.resolved === true,
+});
+
 const importedFeedback = (item, path, entry, host) => {
   const hunk = item.hunk;
   return {
@@ -281,17 +301,100 @@ const changeFiles = (items) => {
   return [...rels];
 };
 
+const requestOptions = (options) => ({
+  fetch: options.fetch ?? globalThis.fetch,
+  token: options.token ?? '',
+  retry: options.retry ?? {},
+  signal: options.signal,
+});
+
+const stateIs = (state, name) => `${state ?? ''}`.toLowerCase() === name;
+
+const issueChange = (site, issue) => {
+  const number = issue.number || 0;
+  const tail = number ? `/${number}` : '';
+  return {
+    id: `${site.id}${tail}`,
+    source: 'issue',
+    title: issue.title || '',
+    author: issue.author || '',
+    base: '',
+    head: '',
+    url: issue.url || `${site.page}${tail}`,
+    repository: site.repository,
+    number,
+  };
+};
+
+const issueTasks = (source, issue, url, comments) => {
+  const { host, readComment } = source;
+  const tasks = [];
+  const body = issueText(issue.title, issue.body);
+  if (body) {
+    const resolved = stateIs(issue.state, 'closed');
+    const entry = { reviewer: issue.author, body, resolved, url };
+    tasks.push(issueTodo(entry, host));
+  }
+  for (const comment of comments) {
+    const entry = readComment(comment);
+    if (!entry || !commentBody(entry.body)) continue;
+    tasks.push(issueTodo(entry, host));
+  }
+  return tasks;
+};
+
+const loadIssue = async (ref, options, source) => {
+  const { client, site, issuesUrl, readIssue } = source;
+  const request = { ...requestOptions(options), subject: 'issue' };
+  const readComments = (number) => {
+    const url = `${issuesUrl}/${number}/${source.comments}`;
+    return client.list(listUrl(url), request);
+  };
+  const tasks = [];
+  let change = issueChange(site, {});
+  if (ref.list) {
+    const open = listUrl(`${issuesUrl}?state=${source.openState}`);
+    for (const data of await client.list(open, request)) {
+      if (!source.isOpen(data)) continue;
+      const issue = readIssue(data);
+      const quiet = issue.comments === 0;
+      const comments = quiet ? [] : await readComments(issue.number);
+      const { url } = issueChange(site, issue);
+      tasks.push(...issueTasks(source, issue, url, comments));
+    }
+  } else {
+    const [page, comments] = await Promise.all([
+      client.request(`${issuesUrl}/${ref.number}`, request),
+      readComments(ref.number),
+    ]);
+    const data = client.parseJson(page.body, 'issue payload');
+    const issue = readIssue(data);
+    issue.number ||= ref.number;
+    change = issueChange(site, issue);
+    tasks.push(...issueTasks(source, issue, change.url, comments));
+  }
+  return {
+    top: options.cwd,
+    items: [],
+    sourceLabel: ref.list ? site.repository : `#${change.number}`,
+    change,
+    imported: { feedback: [], tasks },
+  };
+};
+
 const loadChange = async (ref, options, source) => {
   const { client, url, diffUrl = url, diffAccept } = source;
-  const { cwd, paths = [], fetch = globalThis.fetch } = options;
-  const { token = '', retry = {}, signal } = options;
-  const request = { fetch, token, retry, signal };
-  const jsonPage = await client.request(url, request);
+  const { cwd, paths = [], signal } = options;
+  const request = requestOptions(options);
+  const discussion = Promise.resolve().then(() =>
+    source.loadDiscussion(ref, request),
+  );
+  discussion.catch(() => {});
+  const [jsonPage, diffPage] = await Promise.all([
+    client.request(url, request),
+    client.request(diffUrl, { ...request, accept: diffAccept }),
+  ]);
   const data = client.parseJson(jsonPage.body, `${client.subject} payload`);
-  const diffPage = await client.request(diffUrl, {
-    ...request,
-    accept: diffAccept,
-  });
   const files = filterChangeFiles(parseDiff(diffPage.body), paths);
   const items = foldDepItems(itemsFromFiles(files, 'pr'));
   const change = {
@@ -302,8 +405,7 @@ const loadChange = async (ref, options, source) => {
   const sourceLabel = `${source.prefix}${change.number}`;
   let imported = { feedback: [], tasks: [] };
   try {
-    const discussion = await source.loadDiscussion(ref, request);
-    imported = source.discussionToNotes(discussion, items, paths);
+    imported = source.discussionToNotes(await discussion, items, paths);
   } catch (error) {
     if (isAbortError(error, signal)) throw error;
   }
@@ -320,6 +422,8 @@ module.exports = {
   importedTodo,
   noteFromLocation,
   splitNotes,
+  stateIs,
   filterChangeFiles,
+  loadIssue,
   loadChange,
 };

package/lib/source/review-threads.graphql

@@ -0,0 +1,20 @@
+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
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/lib/source/source.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const github = require('./github.js');
+const gitlab = require('./gitlab.js');
+const { capabilitiesFor, attachCapabilities } = require('./capabilities.js');
+const { parseGithubPrUrl, parseGithubIssueUrl } = github;
+const { parseGithubIssueListUrl } = github;
+const { parseGitlabMrUrl, parseGitlabIssueUrl } = gitlab;
+const { parseGitlabIssueListUrl } = gitlab;
+
+const REMOTE_KINDS = {
+  pr: {
+    option: 'loadPullRequest',
+    load: github.loadPullRequest,
+    token: github.githubToken,
+    target: (selected) => selected.pr,
+  },
+  mr: {
+    option: 'loadMergeRequest',
+    load: gitlab.loadMergeRequest,
+    token: gitlab.gitlabToken,
+    target: (selected) => selected.mr,
+  },
+  issue: {
+    option: 'loadGithubIssue',
+    load: github.loadGithubIssue,
+    token: github.githubToken,
+    target: (selected) => selected.issue,
+  },
+  'gl-issue': {
+    option: 'loadGitlabIssue',
+    load: gitlab.loadGitlabIssue,
+    token: gitlab.gitlabToken,
+    target: (selected) => selected.issue,
+  },
+};
+
+const remoteKind = (selected) => REMOTE_KINDS[selected.kind] ?? null;
+
+const selectChangeSource = (paths) => {
+  if (!paths.length) return { kind: 'local', paths };
+  const first = paths[0];
+  const rest = paths.slice(1);
+  const pr = parseGithubPrUrl(first);
+  if (pr) return { kind: 'pr', pr, paths: rest };
+  const githubIssue = parseGithubIssueUrl(first);
+  if (githubIssue) return { kind: 'issue', issue: githubIssue, paths: rest };
+  const githubIssues = parseGithubIssueListUrl(first);
+  if (githubIssues) return { kind: 'issue', issue: githubIssues, paths: rest };
+  const mr = parseGitlabMrUrl(first);
+  if (mr) return { kind: 'mr', mr, paths: rest };
+  const gitlabIssue = parseGitlabIssueUrl(first);
+  if (gitlabIssue) return { kind: 'gl-issue', issue: gitlabIssue, paths: rest };
+  const gitlabIssues = parseGitlabIssueListUrl(first);
+  if (gitlabIssues) {
+    return { kind: 'gl-issue', issue: gitlabIssues, paths: rest };
+  }
+  return { kind: 'local', paths };
+};
+
+const createLoadedSource = (loaded, kind = 'pr', extra = {}) => {
+  const load = async () => {
+    const items = loaded.items ?? [];
+    return { ...loaded, items: [...items] };
+  };
+  const impl = { load: extra.load ?? load, resolveRev: () => null };
+  return attachCapabilities(impl, capabilitiesFor(kind));
+};
+
+module.exports = {
+  remoteKind,
+  selectChangeSource,
+  createLoadedSource,
+};