reslop 0.1.3 → 0.1.4

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## [Unreleased][unreleased]
 
+## [0.1.4][] - 2026-09-13
+
+- Support a GitLab MR by URL and import review comments
+- Support Windows: npm.cmd, clip, terminal resize, installer
+- Added `-r` read-only mode that blocks stage, unstage, revert, npm
+- Fixed `npm test` so it finds tests on Windows, macOS, and Node 18
+- Added Testing CI on Linux, macOS, and Windows
+
 ## [0.1.3][] - 2026-09-12
 
 - Showed added/removed and staged/total counts in the file list
@@ -33,7 +41,8 @@
 - Feedback and todos that produce a repair plan for an agent
 - Intra-line highlighting in unified, mixed, and side-by-side layouts
 
-[unreleased]: https://github.com/tshemsedinov/reslop/compare/v0.1.3...HEAD
+[unreleased]: https://github.com/tshemsedinov/reslop/compare/v0.1.4...HEAD
+[0.1.4]: https://github.com/tshemsedinov/reslop/compare/v0.1.3...v0.1.4
 [0.1.3]: https://github.com/tshemsedinov/reslop/compare/v0.1.2...v0.1.3
 [0.1.2]: https://github.com/tshemsedinov/reslop/compare/v0.1.1...v0.1.2
 [0.1.1]: https://github.com/tshemsedinov/reslop/compare/v0.1.0...v0.1.1

package/README.md

@@ -1,4 +1,11 @@
-# reslop — Review diff and plan changes
+# 👁️ reslop — Review diff and plan changes
+
+[![ci status](https://github.com/tshemsedinov/reslop/workflows/Testing%20CI/badge.svg)](https://github.com/tshemsedinov/reslop/actions?query=workflow%3A%22Testing+CI%22+branch%3Amain)
+[![snyk](https://snyk.io/test/github/tshemsedinov/reslop/badge.svg)](https://snyk.io/test/github/tshemsedinov/reslop)
+[![npm version](https://badge.fury.io/js/reslop.svg)](https://badge.fury.io/js/reslop)
+[![npm downloads/month](https://img.shields.io/npm/dm/reslop.svg)](https://www.npmjs.com/package/reslop)
+[![npm downloads](https://img.shields.io/npm/dt/reslop.svg)](https://www.npmjs.com/package/reslop)
+[![license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/tshemsedinov/reslop/blob/main/LICENSE)
 
 > Turn generated changes into owned changes
 
@@ -9,35 +16,29 @@ for the agent.
 Review → Plan → Repair → Verify
 ```
 
-- Review uncommitted git diffs, a given commit, or a GitHub pull request.
+- Review uncommitted git diffs, a given commit, a GitHub PR, or a GitLab MR.
 - Stage, unstage, or revert each contiguous block of diff lines.
 - Leave feedback and todos that become a repair plan for the agent.
-- Import GitHub pull request review comments into the local plan for AI.
+- Import GitHub PR and GitLab MR review comments into the local plan for AI.
 - Review each npm dependency once across `package.json` and the lockfile.
 - Propose unused removals, npm audit fixes, and outdated updates as diffs.
 
-Commit and pull request review is read-only. Applying a dependency
-proposal stages the files and runs `npm i` or `npm uninstall`.
-
-Intra-line highlighting paints the words that actually changed in a
-stronger red/green. A close edit inside one word still marks only
-those characters.
-
 ## Install
 
 ```bash
 npm i -g reslop
 ```
 
+Works on Linux, macOS, and Windows. On Windows use Windows Terminal.
+
 ## Usage
 
-```bash
-reslop
-reslop -n
-reslop path/file
-reslop 7ac260c
-reslop https://github.com/metarhia/metacom/pull/555
-```
+- `reslop` uncommitted diffs in this repository
+- `reslop path/file` show only that path or file
+- `reslop 7ac260c` show that commit (read-only)
+- `reslop https://github.com/metarhia/metacom/pull/555` GitHub/GitLab PR/MR
+- `reslop -n` start a new review even if the latest is still editing
+- `reslop -r` read-only: no stage, unstage, revert, or npm apply
 
 Reviews go in `.review/YYYY-MM-DD-NN.md` with frontmatter `status`:
 
@@ -46,7 +47,7 @@ Reviews go in `.review/YYYY-MM-DD-NN.md` with frontmatter `status`:
 - `partial`: AI started; some items remain
 - `done`: all items marked `[x]`
 
-## Keys and buttons
+## Hotkeys
 
 | Key                 | Action                                   |
 | ------------------- | ---------------------------------------- |

package/lib/api.js

@@ -8,6 +8,7 @@ const render = require('./render.js');
 const highlight = require('./highlight.js');
 const detect = require('./detect.js');
 const github = require('./github.js');
+const gitlab = require('./gitlab.js');
 const source = require('./source.js');
 const { Session } = require('./session.js');
 const cli = require('./cli.js');
@@ -25,6 +26,8 @@ module.exports = {
   createGitRepo: git.createGitRepo,
   parseGithubPrUrl: github.parseGithubPrUrl,
   loadPullRequest: github.loadPullRequest,
+  parseGitlabMrUrl: gitlab.parseGitlabMrUrl,
+  loadMergeRequest: gitlab.loadMergeRequest,
   selectChangeSource: source.selectChangeSource,
   decodeChunk: keys.decodeChunk,
   hitAction: keys.hitAction,

package/lib/cli.js

@@ -5,6 +5,7 @@ const path = require('node:path');
 
 const { createGitRepo } = require('./git.js');
 const { githubToken, loadPullRequest } = require('./github.js');
+const { gitlabToken, loadMergeRequest } = require('./gitlab.js');
 const { selectChangeSource, createLoadedSource } = require('./source.js');
 const { Session } = require('./session.js');
 
@@ -12,7 +13,22 @@ const HEX_REV = /^[0-9a-f]{4,40}$/i;
 const HEAD_REV = /^HEAD([~^].*)?$/i;
 const RANGE_REV = /[~^]/;
 
-const USAGE = 'Usage: reslop [-n] [path | commit | pr-url]';
+const USAGE = 'Usage: reslop [-n] [-r] [path | commit | pr-url | mr-url]';
+
+const REMOTE_CHANGE = {
+  'github-pr': {
+    load: 'loadPullRequest',
+    fallback: loadPullRequest,
+    token: githubToken,
+    target: (selected) => selected.pr,
+  },
+  'gitlab-mr': {
+    load: 'loadMergeRequest',
+    fallback: loadMergeRequest,
+    token: gitlabToken,
+    target: (selected) => selected.mr,
+  },
+};
 
 const errorMessage = (reason) => {
   if (reason instanceof Error) return reason.message;
@@ -37,17 +53,22 @@ const failUsage = (stderr, reason) => {
 const parseArgv = (argv) => {
   const paths = [];
   let newReview = false;
+  let readOnly = false;
   for (const arg of argv) {
     if (arg === '-n') {
       newReview = true;
       continue;
     }
+    if (arg === '-r') {
+      readOnly = true;
+      continue;
+    }
     if (arg.startsWith('-')) {
       throw new Error(`unknown option ${arg}`);
     }
     paths.push(arg);
   }
-  return { paths, newReview };
+  return { paths, newReview, readOnly };
 };
 
 const looksLikeRev = (spec) => {
@@ -95,6 +116,7 @@ const sessionOptions = (proc, deps, args, env, extra) => ({
   getSize: deps.getSize,
   startPane: 'files',
   newReview: args.newReview,
+  readOnly: args.readOnly,
   audit: true,
   ...extra,
 });
@@ -121,11 +143,12 @@ const openLocalSession = (proc, deps, args, selected, env) => {
   return session;
 };
 
-const openPullRequestSession = async (proc, deps, args, selected, env) => {
+const openRemoteSession = async (proc, deps, args, selected, env) => {
+  const remote = REMOTE_CHANGE[selected.kind];
   const cwd = deps.cwd ?? proc.cwd();
-  const loader = deps.loadPullRequest ?? loadPullRequest;
-  const token = githubToken(env);
-  const loaded = await loader(selected.pr, {
+  const loader = deps[remote.load] ?? remote.fallback;
+  const token = remote.token(env);
+  const loaded = await loader(remote.target(selected), {
     cwd,
     paths: selected.paths,
     token,
@@ -149,8 +172,8 @@ const openPullRequestSession = async (proc, deps, args, selected, env) => {
 const loadSession = async (proc, deps, args) => {
   const env = proc.env ?? {};
   const selected = selectChangeSource(args.paths);
-  if (selected.kind === 'github-pr') {
-    return openPullRequestSession(proc, deps, args, selected, env);
+  if (REMOTE_CHANGE[selected.kind]) {
+    return openRemoteSession(proc, deps, args, selected, env);
   }
   return openLocalSession(proc, deps, args, selected, env);
 };

package/lib/clipboard.js

@@ -3,13 +3,9 @@
 const { spawnSync } = require('node:child_process');
 
 const { ESC } = require('./ansi.js');
+const { clipTools, spawnBase } = require('./sys.js');
 
 const CLIP_TIMEOUT_MS = 1000;
-const CLIP_TOOLS = [
-  { cmd: 'wl-copy', args: [] },
-  { cmd: 'xclip', args: ['-selection', 'clipboard'] },
-  { cmd: 'xsel', args: ['--clipboard', '--input'] },
-];
 
 const osc52 = (text) => {
   const b64 = Buffer.from(text, 'utf8').toString('base64');
@@ -17,11 +13,15 @@ const osc52 = (text) => {
 };
 
 const runClip = (cmd, args, text) => {
-  const result = spawnSync(cmd, args, {
-    input: text,
-    encoding: 'utf8',
-    timeout: CLIP_TIMEOUT_MS,
-  });
+  const result = spawnSync(
+    cmd,
+    args,
+    spawnBase({
+      input: text,
+      encoding: 'utf8',
+      timeout: CLIP_TIMEOUT_MS,
+    }),
+  );
   if (result.error) return false;
   return result.status === 0;
 };
@@ -33,7 +33,7 @@ const copyText = (text, stdout) => {
     stdout.write(osc52(text));
     ok = true;
   }
-  for (const tool of CLIP_TOOLS) {
+  for (const tool of clipTools()) {
     if (runClip(tool.cmd, tool.args, text)) return true;
   }
   return ok;

package/lib/git.js

@@ -7,12 +7,18 @@ const path = require('node:path');
 const diff = require('./diff.js');
 const { parseDiff, synthesizeNewFile, itemsFromFiles } = diff;
 const { itemPath, isPathInScope, REVIEW_DIR } = require('./files.js');
+const { npmBin, spawnBase } = require('./sys.js');
 const deps = require('./deps.js');
 const { foldDepItems, mergeDepFile, depFileMeta } = deps;
 const { collectUsedNames, parseAuditReport, parseOutdatedReport } = deps;
 const { mergeProposedItems, MANIFEST, LOCKFILE } = deps;
 
-const GIT_CONFIG = ['-c', 'core.quotepath=false'];
+const GIT_CONFIG = [
+  '-c',
+  'core.quotepath=false',
+  '-c',
+  'i18n.logOutputEncoding=utf-8',
+];
 const DIFF_OPTS = ['--no-color', '--no-ext-diff', '--no-renames', '-U3'];
 const GIT_ENCODING = 'utf8';
 const GIT_MAX_BUFFER = 32 * 1024 * 1024;
@@ -71,7 +77,7 @@ const runProc = (cmd, args, options = {}) =>
     let stderr = '';
     let settled = false;
     let timer = null;
-    const child = spawn(cmd, args, { cwd, env });
+    const child = spawn(cmd, args, spawnBase({ cwd, env }));
     const finish = (result) => {
       if (settled) return;
       settled = true;
@@ -135,7 +141,7 @@ const runGit = (args, cwd, input) => {
   const env = { ...process.env, GIT_OPTIONAL_LOCKS: '0' };
   const encoding = GIT_ENCODING;
   const maxBuffer = GIT_MAX_BUFFER;
-  const options = { cwd, encoding, input, maxBuffer, env };
+  const options = spawnBase({ cwd, encoding, input, maxBuffer, env });
   const result = spawnSync('git', args, options);
   return gitResult(result);
 };
@@ -275,18 +281,22 @@ const readDepSides = (top, rev, origin, rel) => {
 };
 
 const runNpmJson = (top, args, timeout) => {
-  const result = spawnSync('npm', args, {
-    cwd: top,
-    encoding: GIT_ENCODING,
-    maxBuffer: GIT_MAX_BUFFER,
-    timeout,
-  });
+  const result = spawnSync(
+    npmBin(),
+    args,
+    spawnBase({
+      cwd: top,
+      encoding: GIT_ENCODING,
+      maxBuffer: GIT_MAX_BUFFER,
+      timeout,
+    }),
+  );
   if (result.error) return '';
   return result.stdout || '';
 };
 
 const runNpmJsonAsync = async (top, args, timeout, signal) => {
-  const result = await runProc('npm', args, {
+  const result = await runProc(npmBin(), args, {
     cwd: top,
     encoding: GIT_ENCODING,
     maxBuffer: GIT_MAX_BUFFER,
@@ -443,12 +453,16 @@ const applyDepWorktree = (top, rel, change, origin) => {
 };
 
 const runNpm = (cwd, args) =>
-  spawnSync('npm', args, {
-    cwd,
-    encoding: GIT_ENCODING,
-    maxBuffer: GIT_MAX_BUFFER,
-    timeout: INSTALL_MS,
-  });
+  spawnSync(
+    npmBin(),
+    args,
+    spawnBase({
+      cwd,
+      encoding: GIT_ENCODING,
+      maxBuffer: GIT_MAX_BUFFER,
+      timeout: INSTALL_MS,
+    }),
+  );
 
 const firstDepRel = (files, kind) => {
   for (const rel of files) {

package/lib/gitlab.js

@@ -0,0 +1,520 @@
+'use strict';
+
+const { delay } = require('metautil');
+
+const diff = require('./diff.js');
+const { parseDiff, itemsFromFiles, isCtxType } = diff;
+const { itemPath, isPathInScope } = require('./files.js');
+const { foldDepItems } = require('./deps.js');
+
+const USER_AGENT = 'reslop';
+const JSON_ACCEPT = 'application/json';
+const DIFF_ACCEPT = 'text/plain';
+const RETRY_ATTEMPTS = 3;
+const RETRY_DELAY_MS = 200;
+const TRANSIENT_STATUS = [429, 502, 503, 504];
+const MR_TODO_FILE = 'merge request';
+const LIST_PER_PAGE = 100;
+
+const GITLAB_MR_RE = new RegExp(
+  String.raw`^(?:(https?)://)?(?:www\.)?([^/?#]+)/` +
+    String.raw`(.+?)(?:/-)?/merge_requests/(\d+)` +
+    String.raw`(?:\.diff|\.patch)?` +
+    String.raw`(?:/(?:diffs|commits|pipelines|changes)?)?` +
+    String.raw`/?(?:[?#].*)?$`,
+  'i',
+);
+
+const isRecord = (value) =>
+  !!value && typeof value === 'object' && !Array.isArray(value);
+
+const oneLine = (text) => {
+  const value = `${text ?? ''}`.trim();
+  if (!value) return '';
+  return value.split('\n')[0];
+};
+
+const gitlabError = (code, message) => {
+  const error = new Error(message);
+  error.code = code;
+  return error;
+};
+
+const withStatus = (error, status) => {
+  error.status = status;
+  return error;
+};
+
+const parseGitlabMrUrl = (text) => {
+  if (typeof text !== 'string' || !text) return null;
+  const match = GITLAB_MR_RE.exec(text.trim());
+  if (!match) return null;
+  const scheme = (match[1] || 'https').toLowerCase();
+  const host = match[2];
+  const rawProject = match[3];
+  const project = rawProject.replace(/\.git$/i, '');
+  const number = parseInt(match[4], 10);
+  const hasNumber = Number.isFinite(number) && number >= 1;
+  if (!host || !project || !hasNumber) return null;
+  const origin = `${scheme}://${host}`;
+  return { host, project, number, origin };
+};
+
+const gitlabToken = (env) => {
+  const from = env ?? process.env;
+  return from.GITLAB_TOKEN || from.GL_TOKEN || '';
+};
+
+const parseApiMessage = (body) => {
+  const text = `${body ?? ''}`.trim();
+  if (!text) return '';
+  try {
+    const parsed = JSON.parse(text);
+    if (isRecord(parsed)) {
+      if (typeof parsed.message === 'string') return parsed.message;
+      if (typeof parsed.error === 'string') return parsed.error;
+    }
+  } catch {
+    // ignore: body is not JSON
+  }
+  return oneLine(text);
+};
+
+const gitlabHttpError = (status, body, token) => {
+  const message = parseApiMessage(body);
+  if (status === 404) {
+    const hint = token ? '' : ' (set GITLAB_TOKEN for private repositories)';
+    const error = gitlabError(
+      'GITLAB_NOT_FOUND',
+      `GitLab merge request not found${hint}`,
+    );
+    return withStatus(error, status);
+  }
+  if (status === 401) {
+    const error = gitlabError('GITLAB_AUTH', 'GitLab authentication failed');
+    return withStatus(error, status);
+  }
+  if (status === 429) {
+    const error = gitlabError(
+      'GITLAB_RATE_LIMIT',
+      'GitLab API rate limit exceeded',
+    );
+    return withStatus(error, status);
+  }
+  if (status === 403 && /rate limit/i.test(message)) {
+    const error = gitlabError(
+      'GITLAB_RATE_LIMIT',
+      'GitLab API rate limit exceeded',
+    );
+    return withStatus(error, status);
+  }
+  const detail = message
+    ? `GitLab API: ${oneLine(message)}`
+    : `GitLab API HTTP ${status}`;
+  return withStatus(gitlabError('GITLAB_HTTP', detail), status);
+};
+
+const wrapNetworkError = (error) => {
+  const detail = oneLine(error && error.message);
+  const suffix = detail ? `: ${detail}` : '';
+  const wrapped = gitlabError(
+    'GITLAB_NETWORK',
+    `GitLab request failed${suffix}`,
+  );
+  wrapped.cause = error;
+  return wrapped;
+};
+
+const isRetryable = (error) => {
+  if (error.code === 'GITLAB_NETWORK') return true;
+  return TRANSIENT_STATUS.includes(error.status);
+};
+
+const retry = async (run, options) => {
+  const attempts = options.attempts ?? RETRY_ATTEMPTS;
+  const delayMs = options.delayMs ?? RETRY_DELAY_MS;
+  for (let i = 0; ; i++) {
+    try {
+      return await run();
+    } catch (error) {
+      const isLast = i === attempts - 1;
+      if (isLast || !isRetryable(error)) throw error;
+      await delay(delayMs * (i + 1));
+    }
+  }
+};
+
+const gitlabHeaders = (token, accept) => {
+  const headers = {
+    Accept: accept,
+    'User-Agent': USER_AGENT,
+  };
+  if (!token) return headers;
+  return { ...headers, 'PRIVATE-TOKEN': token };
+};
+
+const headerValue = (headers, name) => {
+  if (!headers) return '';
+  if (typeof headers.get === 'function') {
+    return headers.get(name) || '';
+  }
+  const wanted = name.toLowerCase();
+  for (const key of Object.keys(headers)) {
+    const value = headers[key];
+    if (key.toLowerCase() === wanted) return `${value}`;
+  }
+  return '';
+};
+
+const parseLinkNext = (headers) => {
+  const link = headerValue(headers, 'link');
+  if (!link) return '';
+  for (const part of link.split(',')) {
+    const match = /<([^>]+)>\s*;\s*rel="?next"?/i.exec(part.trim());
+    if (match) return match[1];
+  }
+  return '';
+};
+
+const parseNextPage = (headers, currentUrl) => {
+  const fromLink = parseLinkNext(headers);
+  if (fromLink) return fromLink;
+  const page = headerValue(headers, 'x-next-page');
+  if (!page) return '';
+  const url = new URL(currentUrl);
+  url.searchParams.set('page', page);
+  return url.toString();
+};
+
+const parseGitlabJson = (text, label) => {
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    throw gitlabError('GITLAB_PARSE', `GitLab API: invalid ${label}`);
+  }
+  return data;
+};
+
+const requestGitlab = async (url, options) => {
+  const fetchImpl = options.fetch;
+  if (typeof fetchImpl !== 'function') {
+    throw gitlabError('GITLAB_FETCH', 'fetch is not available');
+  }
+  const token = options.token || '';
+  const headers = gitlabHeaders(token, options.accept);
+  const retryOpts = options.retry ?? {};
+  const method = options.method || 'GET';
+  return retry(async () => {
+    let response;
+    try {
+      response = await fetchImpl(url, { method, headers });
+    } catch (error) {
+      throw wrapNetworkError(error);
+    }
+    const text = await response.text();
+    if (!response.ok) throw gitlabHttpError(response.status, text, token);
+    return { body: text, headers: response.headers };
+  }, retryOpts);
+};
+
+const requestGitlabList = async (url, options) => {
+  const items = [];
+  let next = url;
+  while (next) {
+    const page = await requestGitlab(next, {
+      ...options,
+      accept: JSON_ACCEPT,
+    });
+    const data = parseGitlabJson(page.body, 'list payload');
+    if (!Array.isArray(data)) {
+      throw gitlabError('GITLAB_PARSE', 'GitLab API: invalid list payload');
+    }
+    for (const entry of data) items.push(entry);
+    next = parseNextPage(page.headers, next);
+  }
+  return items;
+};
+
+const changePath = (file) => file.newPath || file.oldPath || '';
+
+const filterChangeFiles = (files, paths) => {
+  if (!paths.length) return files;
+  const kept = [];
+  for (const file of files) {
+    if (isPathInScope(changePath(file), paths)) kept.push(file);
+  }
+  return kept;
+};
+
+const mrApiUrl = (mr) => {
+  const project = encodeURIComponent(mr.project);
+  const base = `${mr.origin}/api/v4/projects/${project}`;
+  return `${base}/merge_requests/${mr.number}`;
+};
+
+const listUrl = (base) => {
+  const url = new URL(base);
+  url.searchParams.set('per_page', `${LIST_PER_PAGE}`);
+  return url.toString();
+};
+
+const readUsername = (user) => {
+  if (!isRecord(user)) return '';
+  return user.username || '';
+};
+
+const readProject = (data, mr) => {
+  const refs = isRecord(data.references) ? data.references : null;
+  const full = refs && refs.full;
+  if (typeof full === 'string') {
+    const cut = full.lastIndexOf('!');
+    if (cut > 0) return full.slice(0, cut);
+  }
+  return mr.project;
+};
+
+const pushChangeFile = (files, seen, rel) => {
+  if (!rel || seen.has(rel)) return;
+  seen.add(rel);
+  files.push(rel);
+};
+
+const changeFiles = (items) => {
+  const files = [];
+  const seen = new Set();
+  for (const item of items) {
+    if (item.dep) {
+      const depFiles = item.dep.files ?? [];
+      for (const rel of depFiles) pushChangeFile(files, seen, rel);
+      continue;
+    }
+    const rel = itemPath(item);
+    pushChangeFile(files, seen, rel);
+  }
+  return files;
+};
+
+const parseMergeRequestPayload = (text) => {
+  const data = parseGitlabJson(text, 'merge request payload');
+  if (!isRecord(data)) {
+    throw gitlabError(
+      'GITLAB_PARSE',
+      'GitLab API: invalid merge request payload',
+    );
+  }
+  return data;
+};
+
+const toChange = (mr, data, items) => {
+  const number = data.iid || mr.number;
+  const repository = readProject(data, mr);
+  const title = data.title || '';
+  const author = readUsername(data.author);
+  const files = changeFiles(items);
+  const base = data.target_branch || '';
+  const head = data.source_branch || '';
+  const fallbackUrl = `${mr.origin}/${repository}/-/merge_requests/${number}`;
+  const url = data.web_url || fallbackUrl;
+  const id = `${mr.host}/${repository}/merge_requests/${number}`;
+  return {
+    id,
+    source: 'gitlab-mr',
+    title,
+    author,
+    files,
+    status: 'reviewing',
+    base,
+    head,
+    url,
+    repository,
+    number,
+  };
+};
+
+const readCommentBody = (value) => `${value ?? ''}`.trim();
+
+const reviewerOf = (record) => {
+  const login = readUsername(record && record.author);
+  return login || 'unknown';
+};
+
+const formatImportedText = (entry) => {
+  const reviewer = entry.reviewer || 'unknown';
+  const body = `${entry.body ?? ''}`.trim();
+  return `@${reviewer} review at gitlab: ${body}`;
+};
+
+const noteLine = (position) => {
+  if (!isRecord(position)) return { side: 'RIGHT', line: 0 };
+  const kind = position.position_type || 'text';
+  if (kind === 'file' || kind === 'image') {
+    return { side: 'RIGHT', line: 0 };
+  }
+  const newLine = Number(position.new_line);
+  if (Number.isFinite(newLine) && newLine >= 1) {
+    return { side: 'RIGHT', line: newLine };
+  }
+  const oldLine = Number(position.old_line);
+  if (Number.isFinite(oldLine) && oldLine >= 1) {
+    return { side: 'LEFT', line: oldLine };
+  }
+  return { side: 'RIGHT', line: 0 };
+};
+
+const sideLineNumber = (type, oldNo, newNo, side) => {
+  if (side === 'LEFT') {
+    if (type === 'add') return 0;
+    return oldNo;
+  }
+  if (type === 'del') return 0;
+  return newNo;
+};
+
+const locateLineInItem = (item, rel, line, side) => {
+  const path = itemPath(item);
+  if (path !== rel) return null;
+  const hunk = item.hunk;
+  if (!hunk || !line) return null;
+  let oldNo = hunk.oldStart;
+  let newNo = hunk.newStart;
+  for (const entry of hunk.lines) {
+    const at = sideLineNumber(entry.type, oldNo, newNo, side);
+    if (at === line) {
+      const inBlock = entry.blockId === item.blockId;
+      return { inBlock };
+    }
+    if (isCtxType(entry.type) || entry.type === 'del') {
+      oldNo += 1;
+    }
+    if (isCtxType(entry.type) || entry.type === 'add') {
+      newNo += 1;
+    }
+  }
+  return null;
+};
+
+const findItemForLine = (items, rel, line, side) => {
+  let fallback = null;
+  for (const item of items) {
+    const hit = locateLineInItem(item, rel, line, side);
+    if (!hit) continue;
+    if (hit.inBlock) return item;
+    if (!fallback) fallback = item;
+  }
+  return fallback;
+};
+
+const toImportedTodo = (file, entry) => ({
+  kind: 'todo',
+  file,
+  text: formatImportedText(entry),
+  done: entry.resolved === true,
+});
+
+const noteToImported = (note, items, paths) => {
+  if (!isRecord(note) || note.system === true) return null;
+  const body = readCommentBody(note.body);
+  if (!body) return null;
+  const resolved = note.resolved === true;
+  const entry = {
+    reviewer: reviewerOf(note),
+    body,
+    resolved,
+  };
+  if (note.type !== 'DiffNote') {
+    return toImportedTodo(MR_TODO_FILE, entry);
+  }
+  const position = isRecord(note.position) ? note.position : null;
+  const path = position ? position.new_path || position.old_path || '' : '';
+  if (path && !isPathInScope(path, paths)) return null;
+  const { side, line } = noteLine(position);
+  const isFile = !line;
+  if (!isFile && path) {
+    const item = findItemForLine(items, path, line, side);
+    if (item) {
+      const hunk = item.hunk;
+      return {
+        kind: 'feedback',
+        file: itemPath(item) || path,
+        oldStart: hunk ? hunk.oldStart : 0,
+        newStart: hunk ? hunk.newStart : 0,
+        blockId: item.blockId ?? 0,
+        origin: item.origin ?? 'pr',
+        header: hunk ? hunk.header : '',
+        text: formatImportedText(entry),
+        done: resolved,
+      };
+    }
+  }
+  if (path) return toImportedTodo(path, entry);
+  return toImportedTodo(MR_TODO_FILE, entry);
+};
+
+const discussionToNotes = (discussions, items, paths = []) => {
+  const feedback = [];
+  const todos = [];
+  const threads = discussions ?? [];
+  for (const discussion of threads) {
+    if (!isRecord(discussion)) continue;
+    const notes = Array.isArray(discussion.notes) ? discussion.notes : [];
+    for (const note of notes) {
+      const mapped = noteToImported(note, items, paths);
+      if (!mapped) continue;
+      if (mapped.kind === 'feedback') feedback.push(mapped);
+      else todos.push(mapped);
+    }
+  }
+  return { feedback, todos };
+};
+
+const loadDiscussion = async (mr, options) => {
+  const url = listUrl(`${mrApiUrl(mr)}/discussions`);
+  return requestGitlabList(url, options);
+};
+
+const loadImportedNotes = async (mr, items, paths, options) => {
+  try {
+    const discussions = await loadDiscussion(mr, options);
+    return discussionToNotes(discussions, items, paths);
+  } catch {
+    // ignore: discussion import is optional
+    return { feedback: [], todos: [] };
+  }
+};
+
+const loadMergeRequest = async (mr, options = {}) => {
+  const token = options.token ?? '';
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const paths = options.paths ?? [];
+  const retryOpts = options.retry ?? {};
+  const url = mrApiUrl(mr);
+  const request = { fetch: fetchImpl, token, retry: retryOpts };
+  const jsonPage = await requestGitlab(url, {
+    ...request,
+    accept: JSON_ACCEPT,
+  });
+  const data = parseMergeRequestPayload(jsonPage.body);
+  const diffPage = await requestGitlab(`${url}/raw_diffs`, {
+    ...request,
+    accept: DIFF_ACCEPT,
+  });
+  const parsed = parseDiff(diffPage.body);
+  const files = filterChangeFiles(parsed, paths);
+  const parsedItems = itemsFromFiles(files, 'pr');
+  const items = foldDepItems(parsedItems);
+  const change = toChange(mr, data, items);
+  const sourceLabel = `!${change.number}`;
+  const imported = await loadImportedNotes(mr, items, paths, request);
+  return { top: options.cwd, items, sourceLabel, change, imported };
+};
+
+module.exports = {
+  parseGitlabMrUrl,
+  gitlabToken,
+  filterChangeFiles,
+  mrApiUrl,
+  formatImportedText,
+  discussionToNotes,
+  loadMergeRequest,
+};

package/lib/render.js

@@ -514,12 +514,15 @@ const paintButtons = (layout, width, color) => {
   return out;
 };
 
+const remoteCounts = (kind, { counts, notes, sourceLabel }) => {
+  const n = counts.pr ?? 0;
+  const label = sourceLabel || kind;
+  return ` ${kind} ${label}  ${n}  ${notes}`;
+};
+
 const COUNTS_KIND = {
-  pr: ({ counts, notes, sourceLabel }) => {
-    const n = counts.pr ?? 0;
-    const label = sourceLabel || 'pr';
-    return ` pr ${label}  ${n}  ${notes}`;
-  },
+  pr: (args) => remoteCounts('pr', args),
+  mr: (args) => remoteCounts('mr', args),
   commit: ({ counts, notes, revShort }) => {
     const n = counts.commit ?? 0;
     return ` commit ${revShort}  ${n}  ${notes}`;
@@ -535,7 +538,7 @@ const COUNTS_KIND = {
 };
 
 const countsKind = (sourceKind, revShort) => {
-  if (sourceKind === 'pr') return 'pr';
+  if (sourceKind === 'pr' || sourceKind === 'mr') return sourceKind;
   if (revShort) return 'commit';
   return 'worktree';
 };

package/lib/session.js

@@ -9,6 +9,7 @@ const review = require('./review.js');
 const wrap = require('./wrap.js');
 const { extractText, isRange } = require('./select.js');
 const { copyText } = require('./clipboard.js');
+const { watchResize } = require('./sys.js');
 const { fileEntries, itemPath } = require('./files.js');
 const { Editor } = require('./editor.js');
 const { refreshIndexPatches } = require('./diff.js');
@@ -29,6 +30,10 @@ const { prefixTemplates, TEMPLATE_SHOW, rememberTemplate } = review;
 
 const LAYOUTS = ['unified', 'mixed', 'side'];
 const READ_ONLY_ORIGINS = ['commit', 'pr'];
+const SOURCE_KIND = {
+  'github-pr': 'pr',
+  'gitlab-mr': 'mr',
+};
 const ENTER_TERM = '\x1b[?1049h\x1b[?25l\x1b[?7l\x1b[?1002h\x1b[?1006h';
 const LEAVE_TERM =
   '\x1b[?1006l\x1b[?1002l\x1b[?7h\x1b[0 q\x1b[?12l\x1b[?25h\x1b[?1049l';
@@ -197,6 +202,7 @@ class Session {
     this.mkdirSync = options.mkdirSync ?? fs.mkdirSync;
     this.now = options.now ?? systemNow;
     this.forceNewReview = options.newReview === true;
+    this.readOnly = options.readOnly === true;
     this.audit = options.audit === true;
     this.outdatedMap = options.outdatedMap;
     this.auditMap = options.auditMap;
@@ -538,7 +544,7 @@ class Session {
   view() {
     const templates = this.shownTemplates();
     const change = this.change;
-    const isGithubPr = change && change.source === 'github-pr';
+    const sourceKind = (change && SOURCE_KIND[change.source]) || '';
     const repoName = this.repoName || path.basename(this.top || this.cwd || '');
     return {
       item: this.current(),
@@ -556,7 +562,7 @@ class Session {
       repoName,
       revShort: this.revShort || '',
       sourceLabel: this.sourceLabel || '',
-      sourceKind: isGithubPr ? 'pr' : '',
+      sourceKind,
       mode: this.mode,
       compose: this.composeView(),
       noteText: this.idleNoteText(),
@@ -692,16 +698,20 @@ class Session {
     return items;
   }
 
-  guardFileGit(items) {
-    if (!items.length) return false;
-    const first = items[0];
-    if (isReadOnlyOrigin(first.origin)) {
+  guardWritable(item) {
+    if (!item) return false;
+    if (this.readOnly || isReadOnlyOrigin(item.origin)) {
       this.status = 'read only';
       return false;
     }
     return true;
   }
 
+  guardFileGit(items) {
+    if (!items.length) return false;
+    return this.guardWritable(items[0]);
+  }
+
   applyFileGit(items, label, write, afterItem) {
     try {
       for (const item of items) {
@@ -797,11 +807,7 @@ class Session {
   onAdd() {
     if (this.pane === 'files') return void this.onFileAdd();
     const item = this.activeDiffItem();
-    if (!item) return;
-    if (isReadOnlyOrigin(item.origin)) {
-      this.status = 'read only';
-      return;
-    }
+    if (!this.guardWritable(item)) return;
     if (item.origin === 'staged') {
       this.status = 'already staged';
       return;
@@ -823,11 +829,7 @@ class Session {
   onUnstage() {
     if (this.pane === 'files') return void this.onFileUnstage();
     const item = this.activeDiffItem();
-    if (!item) return;
-    if (isReadOnlyOrigin(item.origin)) {
-      this.status = 'read only';
-      return;
-    }
+    if (!this.guardWritable(item)) return;
     if (item.origin !== 'staged') {
       this.status = 'not staged';
       return;
@@ -844,11 +846,7 @@ class Session {
   onRevert() {
     if (this.pane === 'files') return void this.onFileRevert();
     const item = this.activeDiffItem();
-    if (!item) return;
-    if (isReadOnlyOrigin(item.origin)) {
-      this.status = 'read only';
-      return;
-    }
+    if (!this.guardWritable(item)) return;
     this.applyGit(
       item,
       'reverted',
@@ -1653,7 +1651,7 @@ class Session {
         CURSOR_BLINK_MS,
       );
       this.stdin.on('data', (chunk) => onData(chunk), { signal });
-      process.on('SIGWINCH', () => this.draw(), { signal });
+      watchResize(this.stdout, process, () => this.draw(), signal);
     });
   }
 }

package/lib/source.js

@@ -1,13 +1,16 @@
 'use strict';
 
 const { parseGithubPrUrl } = require('./github.js');
+const { parseGitlabMrUrl } = require('./gitlab.js');
 
 const selectChangeSource = (paths) => {
   if (!paths.length) return { kind: 'local', paths };
   const first = paths[0];
   const pr = parseGithubPrUrl(first);
-  if (!pr) return { kind: 'local', paths };
-  return { kind: 'github-pr', pr, paths: paths.slice(1) };
+  if (pr) return { kind: 'github-pr', pr, paths: paths.slice(1) };
+  const mr = parseGitlabMrUrl(first);
+  if (mr) return { kind: 'gitlab-mr', mr, paths: paths.slice(1) };
+  return { kind: 'local', paths };
 };
 
 const nop = () => {};

package/lib/sys.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const IS_WIN = process.platform === 'win32';
+
+const UNIX_CLIP = [
+  { cmd: 'wl-copy', args: [] },
+  { cmd: 'xclip', args: ['-selection', 'clipboard'] },
+  { cmd: 'xsel', args: ['--clipboard', '--input'] },
+];
+
+const npmBin = (platform = process.platform) =>
+  platform === 'win32' ? 'npm.cmd' : 'npm';
+
+const spawnBase = (extra = {}) => ({ windowsHide: true, ...extra });
+
+const clipTools = (platform = process.platform) => {
+  if (platform === 'win32') return [{ cmd: 'clip', args: [] }];
+  if (platform === 'darwin') return [{ cmd: 'pbcopy', args: [] }];
+  return UNIX_CLIP;
+};
+
+const watchResize = (stdout, proc, onResize, signal) => {
+  if (stdout && typeof stdout.on === 'function') {
+    stdout.on('resize', onResize, { signal });
+  }
+  try {
+    proc.on('SIGWINCH', onResize, { signal });
+  } catch {
+    // SIGWINCH is not available on Windows
+  }
+};
+
+const canonPath = (value) => {
+  try {
+    return fs.realpathSync.native(value);
+  } catch {
+    return path.resolve(value);
+  }
+};
+
+const samePath = (left, right) => {
+  if (left === right) return true;
+  const a = canonPath(left);
+  const b = canonPath(right);
+  if (a === b) return true;
+  return IS_WIN && a.toLowerCase() === b.toLowerCase();
+};
+
+module.exports = {
+  IS_WIN,
+  npmBin,
+  spawnBase,
+  clipTools,
+  watchResize,
+  samePath,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reslop",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Interactive code review and repair planning for AI-assisted changes",
   "keywords": [
     "code-review",
@@ -53,7 +53,7 @@
     "disable": "node scripts/disable.js",
     "lint": "eslint . && prettier -c \"**/*.js\" \"**/*.json\" \"**/*.md\"",
     "fix": "eslint . --fix && prettier --write \"**/*.js\" \"**/*.json\" \"**/*.md\"",
-    "test": "npm run -s lint && node --test test/*.test.js"
+    "test": "npm run -s lint && node --test"
   },
   "devDependencies": {
     "eslint": "^9.39.4",