reslop 0.0.1 → 0.1.1

package/CHANGELOG.md

@@ -2,7 +2,24 @@
 
 ## [Unreleased][unreleased]
 
-## [0.0.1][] - 2026-01-01
+## [0.1.1][] - 2026-09-10
 
-[unreleased]: https://github.com/tshemsedinov/reslop/compare/v0.0.1...HEAD
-[0.0.1]: https://github.com/tshemsedinov/reslop/releases/tag/v0.0.1
+- Open a GitHub pull request by URL and review its diff
+- Import GitHub pull request review comments into the local review
+- Improve TUI navigation and hotkeys
+- CLI simplification and optimisation
+- Dix diff highlighting for snake_case identifier changes
+- Updated package metadata and README
+
+## [0.1.0][] - 2026-09-07
+
+### Added
+
+- Interactive terminal review of uncommitted git diffs with stage, unstage,
+  revert, and skip
+- 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.1...HEAD
+[0.1.1]: https://github.com/tshemsedinov/reslop/compare/v0.1.0...v0.1.1
+[0.1.0]: https://github.com/tshemsedinov/reslop/releases/tag/v0.1.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017-2026 Metarhia contributors
+Copyright (c) 2026 Timur Shemsedinov
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,7 +1,70 @@
-# reslop
+# reslop — Review diff and plan changes
 
-Interactive terminal code review git diff with intra-line highlighting.
+> Turn generated changes into owned changes
 
-## License & Contributors
+```text
+Review → Plan → Repair → Verify
+```
 
-Copyright (c) 2026 Metarhia contributors. [MIT licensed](./LICENSE).
+`0.1.x` implements Review: open a change, leave findings and todos, and
+prepare a repair plan for the agent. Plan, repair, and verify come later.
+
+- Prepare review findings and a repair plan for the agent.
+- Leave feedback, add todos.
+- Generate a plan the agent executes.
+
+Walk uncommitted git changes, a given commit, or a GitHub pull request.
+Each contiguous block of diff lines can be staged, unstaged, reverted;
+add review and todos. Commit and pull request review is read-only.
+
+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
+```
+
+## Usage
+
+```bash
+reslop
+reslop -n
+reslop path/file
+reslop 7ac260c
+reslop https://github.com/metarhia/metacom/pull/555
+```
+
+Reviews go in `.review/YYYY-MM-DD-NN.md` with frontmatter `status`:
+
+- `editing`: still writing the review in reslop
+- `ready`: ready for AI to work through the checkboxes
+- `partial`: AI started; some items remain
+- `done`: all items marked `[x]`
+
+## Keys and buttons
+
+| Key         | Action                                  |
+| ----------- | --------------------------------------- |
+| `a`         | Stage this block (`git add`)            |
+| `u`         | Unstage this block (keep worktree)      |
+| `r`         | Restore this block to the last commit   |
+| `s`         | Skip (leave unstaged, drop from review) |
+| `←`         | Previous remaining block                |
+| `→`         | Next remaining block                    |
+| `l`         | File list (git status of this scope)    |
+| `Esc`       | Quit file list or a tool                |
+| `m`         | Cycle unified / mixed / side-by-side    |
+| `f`         | Feedback on this diff block             |
+| `t`         | New todo for this file                  |
+| `⌫` / `Del` | Remove the selected todo                |
+| `⏎`         | Open the selected file                  |
+| `q`         | Quit                                    |
+| `?`         | Help                                    |
+
+## License
+
+Copyright (c) 2026 Timur Shemsedinov.
+This is [MIT](./LICENSE) licensed software.

package/bin/reslop.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+'use strict';
+
+const { run, errorMessage } = require('../lib/cli.js');
+const { LEAVE_TERM } = require('../lib/session.js');
+
+const fail = (reason) => {
+  try {
+    process.stdout.write(LEAVE_TERM);
+  } catch {}
+  process.stderr.write(`reslop: ${errorMessage(reason)}\n`);
+  process.exit(1);
+};
+
+process.on('uncaughtException', (error) => fail(error));
+process.on('unhandledRejection', (reason) => fail(reason));
+
+run(process).then(
+  (code) => {
+    process.exit(code);
+  },
+  (error) => fail(error),
+);

package/lib/ansi.js

@@ -0,0 +1,231 @@
+'use strict';
+
+const SEGMENTER = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+
+const ESC = String.fromCodePoint(0x1b);
+const ANSI_RE = new RegExp(`${ESC}\\[[0-9;?]*[ -/]*[@-~]`, 'g');
+const RESET = `${ESC}[0m`;
+const BOLD = `${ESC}[1m`;
+const EL = `${ESC}[K`;
+
+const WIDE_CP = [
+  0x1100, 0x115f, 0x231a, 0x231b, 0x2329, 0x232a, 0x23e9, 0x23ec, 0x23f0,
+  0x23f0, 0x23f3, 0x23f3, 0x25fd, 0x25fe, 0x2614, 0x2615, 0x2630, 0x2637,
+  0x2648, 0x2653, 0x267f, 0x267f, 0x268a, 0x268f, 0x2693, 0x2693, 0x26a1,
+  0x26a1, 0x26aa, 0x26ab, 0x26bd, 0x26be, 0x26c4, 0x26c5, 0x26ce, 0x26ce,
+  0x26d4, 0x26d4, 0x26ea, 0x26ea, 0x26f2, 0x26f3, 0x26f5, 0x26f5, 0x26fa,
+  0x26fa, 0x26fd, 0x26fd, 0x2705, 0x2705, 0x270a, 0x270b, 0x2728, 0x2728,
+  0x274c, 0x274c, 0x274e, 0x274e, 0x2753, 0x2755, 0x2757, 0x2757, 0x2795,
+  0x2797, 0x27b0, 0x27b0, 0x27bf, 0x27bf, 0x2b1b, 0x2b1c, 0x2b50, 0x2b50,
+  0x2b55, 0x2b55, 0x2e80, 0x2e99, 0x2e9b, 0x2ef3, 0x2f00, 0x2fd5, 0x2ff0,
+  0x303e, 0x3041, 0x3096, 0x3099, 0x30ff, 0x3105, 0x312f, 0x3131, 0x318e,
+  0x3190, 0x31e5, 0x31ef, 0x321e, 0x3220, 0x3247, 0x3250, 0xa48c, 0xa490,
+  0xa4c6, 0xa960, 0xa97c, 0xac00, 0xd7a3, 0xf900, 0xfaff, 0xfe10, 0xfe19,
+  0xfe30, 0xfe52, 0xfe54, 0xfe66, 0xfe68, 0xfe6b, 0xff01, 0xff60, 0xffe0,
+  0xffe6, 0x16fe0, 0x16fe4, 0x16ff0, 0x16ff1, 0x17000, 0x187f7, 0x18800,
+  0x18cd5, 0x18cff, 0x18d08, 0x1aff0, 0x1aff3, 0x1aff5, 0x1affb, 0x1affd,
+  0x1affe, 0x1b000, 0x1b122, 0x1b132, 0x1b132, 0x1b150, 0x1b152, 0x1b155,
+  0x1b155, 0x1b164, 0x1b167, 0x1b170, 0x1b2fb, 0x1d300, 0x1d356, 0x1d360,
+  0x1d376, 0x1f004, 0x1f004, 0x1f0cf, 0x1f0cf, 0x1f18e, 0x1f18e, 0x1f191,
+  0x1f19a, 0x1f200, 0x1f202, 0x1f210, 0x1f23b, 0x1f240, 0x1f248, 0x1f250,
+  0x1f251, 0x1f260, 0x1f265, 0x1f300, 0x1f320, 0x1f32d, 0x1f335, 0x1f337,
+  0x1f37c, 0x1f37e, 0x1f393, 0x1f3a0, 0x1f3ca, 0x1f3cf, 0x1f3d3, 0x1f3e0,
+  0x1f3f0, 0x1f3f4, 0x1f3f4, 0x1f3f8, 0x1f43e, 0x1f440, 0x1f440, 0x1f442,
+  0x1f4fc, 0x1f4ff, 0x1f53d, 0x1f54b, 0x1f54e, 0x1f550, 0x1f567, 0x1f57a,
+  0x1f57a, 0x1f595, 0x1f596, 0x1f5a4, 0x1f5a4, 0x1f5fb, 0x1f64f, 0x1f680,
+  0x1f6c5, 0x1f6cc, 0x1f6cc, 0x1f6d0, 0x1f6d2, 0x1f6d5, 0x1f6d7, 0x1f6dc,
+  0x1f6df, 0x1f6eb, 0x1f6ec, 0x1f6f4, 0x1f6fc, 0x1f7e0, 0x1f7eb, 0x1f7f0,
+  0x1f7f0, 0x1f90c, 0x1f93a, 0x1f93c, 0x1f945, 0x1f947, 0x1f9ff, 0x1fa70,
+  0x1fa7c, 0x1fa80, 0x1fa89, 0x1fa8f, 0x1fac6, 0x1face, 0x1fadc, 0x1fadf,
+  0x1fae9, 0x1faf0, 0x1faf8, 0x20000, 0x2fffd, 0x30000, 0x3fffd,
+];
+
+const THEME = {
+  delLineFg: [0xcc, 0x7a, 0x7a],
+  delLineBg: [0x3a, 0x1a, 0x1a],
+  delCharFg: [0xff, 0xff, 0xff],
+  delCharBg: [0x75, 0x22, 0x22],
+  addLineFg: [0x7a, 0xcc, 0x8a],
+  addLineBg: [0x14, 0x28, 0x14],
+  addCharFg: [0xff, 0xff, 0xff],
+  addCharBg: [0x1a, 0x4c, 0x26],
+  ctxFg: [0x8a, 0x8a, 0x8a],
+  ctxBg: [0x12, 0x12, 0x18],
+  splitGutterFg: [0x18, 0x18, 0x24],
+  splitGutterBg: [0x18, 0x18, 0x24],
+  headerFg: [0x3a, 0x3a, 0x3a],
+  headerBg: [0xe6, 0xe6, 0xee],
+  headerChromeFg: [0x5a, 0x5a, 0x5a],
+  headerRepoFg: [0x3a, 0x3a, 0x3a],
+  headerDirFg: [0x6e, 0x6e, 0x6e],
+  headerSlashFg: [0x8a, 0x8a, 0x8a],
+  headerFileFg: [0x4e, 0x4e, 0x4e],
+  headerMetaFg: [0x5a, 0x5a, 0x5a],
+  chromeFg: [0xd0, 0xd0, 0xe0],
+  chromeBg: [0x18, 0x18, 0x24],
+  noteBg: [0x24, 0x24, 0x36],
+  buttonFg: [0x6a, 0x6a, 0x7e],
+  buttonBg: [0x2a, 0x2a, 0x40],
+  buttonHotFg: [0xff, 0xff, 0xff],
+  checkFg: [0xf4, 0xf4, 0xfc],
+  checkBg: [0x52, 0x52, 0x74],
+  checkDoneFg: [0xf0, 0xff, 0xf4],
+  checkDoneBg: [0x22, 0x58, 0x34],
+  errorFg: [0xff, 0x80, 0x80],
+  warnFg: [0xe8, 0xc8, 0x4a],
+  mutedFg: [0x7a, 0x7a, 0x8a],
+  stagedDelLineFg: [0xa0, 0xa0, 0xa8],
+  stagedDelLineBg: [0x20, 0x20, 0x26],
+  stagedDelCharFg: [0xf0, 0xf0, 0xf4],
+  stagedDelCharBg: [0x44, 0x44, 0x4e],
+  stagedAddLineFg: [0xb0, 0xb0, 0xb8],
+  stagedAddLineBg: [0x26, 0x26, 0x2e],
+  stagedAddCharFg: [0xff, 0xff, 0xff],
+  stagedAddCharBg: [0x4e, 0x4e, 0x58],
+};
+
+const CODE_FG = {
+  keyword: [197, 134, 192],
+  control: [197, 134, 192],
+  storage: [86, 156, 214],
+  literal: [86, 156, 214],
+  string: [206, 145, 120],
+  template: [206, 145, 120],
+  escape: [209, 105, 105],
+  interpolation: [156, 220, 254],
+  number: [181, 206, 168],
+  comment: [106, 153, 85],
+  function: [220, 220, 170],
+  method: [220, 220, 170],
+  className: [78, 201, 176],
+  type: [78, 201, 176],
+  interface: [78, 201, 176],
+  property: [156, 220, 254],
+  variable: [156, 220, 254],
+  parameter: [156, 220, 254],
+  constant: [79, 193, 255],
+  operator: [212, 212, 212],
+  punct: [212, 212, 212],
+  regex: [209, 105, 105],
+  decorator: [220, 220, 170],
+  tag: [86, 156, 214],
+  attr: [156, 220, 254],
+  plain: [212, 212, 212],
+  punctDim: [128, 128, 128],
+  logDate: [210, 210, 220],
+  logError: [230, 90, 90],
+  logWarn: [230, 180, 80],
+  logInfo: [100, 170, 230],
+  logDebug: [140, 160, 180],
+};
+
+const LOG_COL_FG = [
+  [210, 210, 220],
+  [120, 180, 220],
+  [180, 160, 220],
+  [140, 200, 160],
+  [220, 180, 120],
+  [220, 140, 160],
+  [160, 200, 200],
+  [200, 170, 140],
+];
+
+const codeFg = (style) => {
+  if (typeof style !== 'string') return CODE_FG.plain;
+  if (Object.hasOwn(CODE_FG, style)) return CODE_FG[style];
+  if (style.startsWith('logCol')) {
+    const i = parseInt(style.slice(6), 10);
+    return LOG_COL_FG[i % LOG_COL_FG.length];
+  }
+  return CODE_FG.plain;
+};
+
+const fg = (rgb) => `${ESC}[38;2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+
+const bg = (rgb) => `${ESC}[48;2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+
+const seq = (fgRgb, bgRgb) => `${fg(fgRgb)}${bg(bgRgb)}`;
+
+const paint = (text, fgRgb, bgRgb, color, bold) => {
+  if (!color || text === '') return text;
+  const mark = bold ? BOLD : '';
+  return `${mark}${seq(fgRgb, bgRgb)}${text}${RESET}`;
+};
+
+const stripAnsi = (text) => text.replace(ANSI_RE, '');
+
+const graphemes = (text) => {
+  const parts = [];
+  for (const { segment } of SEGMENTER.segment(text)) parts.push(segment);
+  return parts;
+};
+
+const isWide = (cp) => {
+  let lo = 0;
+  let hi = WIDE_CP.length >> 1;
+  while (lo < hi) {
+    const mid = (lo + hi) >> 1;
+    const start = WIDE_CP[mid << 1];
+    const end = WIDE_CP[(mid << 1) + 1];
+    if (cp < start) hi = mid;
+    else if (cp > end) lo = mid + 1;
+    else return true;
+  }
+  return false;
+};
+
+const graphemeWidth = (ch, col) => {
+  if (ch === '\t') return 8 - (col % 8);
+  if (ch === '\n' || ch === '\r') return 0;
+  const cp = ch.codePointAt(0);
+  if (cp <= 0x1f || cp === 0x7f) return 0;
+  if (cp === 0x200d) return 0;
+  if (cp >= 0xfe00 && cp <= 0xfe0f) return 0;
+  if (isWide(cp)) return 2;
+  return 1;
+};
+
+const visibleWidth = (text) => {
+  const plain = stripAnsi(text);
+  let width = 0;
+  for (const ch of graphemes(plain)) {
+    width += graphemeWidth(ch, width);
+  }
+  return width;
+};
+
+const truncateVisible = (text, width) => {
+  if (width <= 0) return '';
+  if (visibleWidth(text) <= width) return text;
+  const plain = stripAnsi(text);
+  const parts = graphemes(plain);
+  let used = 0;
+  let out = '';
+  for (const ch of parts) {
+    const w = graphemeWidth(ch, used);
+    if (used + w > width) break;
+    out += ch;
+    used += w;
+  }
+  return out;
+};
+
+module.exports = {
+  ESC,
+  RESET,
+  BOLD,
+  EL,
+  THEME,
+  CODE_FG,
+  LOG_COL_FG,
+  codeFg,
+  fg,
+  bg,
+  seq,
+  paint,
+  stripAnsi,
+  graphemes,
+  graphemeWidth,
+  visibleWidth,
+  truncateVisible,
+};

package/lib/api.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const ansi = require('./ansi.js');
+const diff = require('./diff.js');
+const git = require('./git.js');
+const keys = require('./keys.js');
+const render = require('./render.js');
+const highlight = require('./highlight.js');
+const detect = require('./detect.js');
+const github = require('./github.js');
+const source = require('./source.js');
+const { Session } = require('./session.js');
+const cli = require('./cli.js');
+
+module.exports = {
+  THEME: ansi.THEME,
+  CODE_FG: ansi.CODE_FG,
+  ACTIONS: keys.ACTIONS,
+  diffChars: diff.diffChars,
+  parseDiff: diff.parseDiff,
+  splitHunk: diff.splitHunk,
+  displayLines: diff.displayLines,
+  formatPatch: diff.formatPatch,
+  itemsFromFiles: diff.itemsFromFiles,
+  createGitRepo: git.createGitRepo,
+  parseGithubPrUrl: github.parseGithubPrUrl,
+  loadPullRequest: github.loadPullRequest,
+  selectChangeSource: source.selectChangeSource,
+  decodeChunk: keys.decodeChunk,
+  hitAction: keys.hitAction,
+  renderFrame: render.renderFrame,
+  tokenize: highlight.tokenize,
+  overlayTokens: highlight.overlayTokens,
+  detectLang: detect.detectLang,
+  run: cli.run,
+  Session,
+};

package/lib/cli.js

@@ -0,0 +1,185 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { createGitRepo } = require('./git.js');
+const { githubToken, loadPullRequest } = require('./github.js');
+const { selectChangeSource, createLoadedSource } = require('./source.js');
+const { Session } = require('./session.js');
+
+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 errorMessage = (reason) => {
+  if (reason instanceof Error) return reason.message;
+  if (reason === null || reason === undefined) return '';
+  if (typeof reason === 'string') return reason;
+  return `${reason}`;
+};
+
+const fail = (stderr, reason) => {
+  stderr.write(`reslop: ${errorMessage(reason)}\n`);
+  return 1;
+};
+
+const failUsage = (stderr, reason) => {
+  fail(stderr, reason);
+  stderr.write(`${USAGE}\n`);
+  return 1;
+};
+
+const parseArgv = (argv) => {
+  const paths = [];
+  let newReview = false;
+  for (const arg of argv) {
+    if (arg === '-n') {
+      newReview = true;
+      continue;
+    }
+    if (arg.startsWith('-')) {
+      throw new Error(`unknown option ${arg}`);
+    }
+    paths.push(arg);
+  }
+  return { paths, newReview };
+};
+
+const looksLikeRev = (spec) => {
+  if (!spec) return false;
+  if (HEX_REV.test(spec)) return true;
+  if (HEAD_REV.test(spec)) return true;
+  return RANGE_REV.test(spec);
+};
+
+const pathExists = (cwd, rel, statSync) => {
+  try {
+    statSync(path.resolve(cwd, rel));
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const resolveScope = (cwd, paths, repo, statSync = fs.statSync) => {
+  if (!paths.length) return { rev: null, paths };
+  const first = paths[0];
+  if (pathExists(cwd, first, statSync)) {
+    return { rev: null, paths };
+  }
+  const resolved = repo.resolveRev ? repo.resolveRev(cwd, first) : null;
+  if (resolved) {
+    if (paths.length > 1) {
+      throw new Error('use a commit or a path, not both');
+    }
+    return { rev: resolved, paths: [] };
+  }
+  if (looksLikeRev(first)) {
+    throw new Error(`bad revision ${first}`);
+  }
+  return { rev: null, paths };
+};
+
+const isColorEnabled = (stdout, env) => stdout.isTTY === true && !env.NO_COLOR;
+
+const openLocalSession = (proc, deps, args, env) => {
+  const stdout = proc.stdout;
+  const repo = deps.repo ?? createGitRepo();
+  const cwd = deps.cwd ?? proc.cwd();
+  const statSync = deps.statSync ?? fs.statSync;
+  const scope = resolveScope(cwd, args.paths, repo, statSync);
+  const session = new Session({
+    repo,
+    cwd,
+    paths: scope.paths,
+    rev: scope.rev,
+    stdin: proc.stdin,
+    stdout,
+    color: isColorEnabled(stdout, env),
+    getSize: deps.getSize,
+    startPane: 'files',
+    newReview: args.newReview,
+  });
+  session.load();
+  return session;
+};
+
+const openPullRequestSession = async (proc, deps, args, selected, env) => {
+  const stdout = proc.stdout;
+  const cwd = deps.cwd ?? proc.cwd();
+  const loader = deps.loadPullRequest ?? loadPullRequest;
+  const token = githubToken(env);
+  const loaded = await loader(selected.pr, {
+    cwd,
+    paths: selected.paths,
+    token,
+    fetch: deps.fetch,
+    env,
+  });
+  const change = loaded.change ?? null;
+  const repository = change ? change.repository : '';
+  const repo = deps.repo ?? createLoadedSource(loaded);
+  const session = new Session({
+    repo,
+    cwd,
+    paths: selected.paths,
+    stdin: proc.stdin,
+    stdout,
+    color: isColorEnabled(stdout, env),
+    getSize: deps.getSize,
+    startPane: 'files',
+    newReview: args.newReview,
+    repoName: repository,
+    sourceLabel: loaded.sourceLabel,
+    change,
+  });
+  session.load();
+  return session;
+};
+
+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);
+  }
+  return openLocalSession(proc, deps, args, env);
+};
+
+const run = async (proc, deps = {}) => {
+  const stdout = proc.stdout;
+  const stderr = proc.stderr;
+  let args;
+  try {
+    args = parseArgv(proc.argv.slice(2));
+  } catch (error) {
+    return failUsage(stderr, error);
+  }
+  let session;
+  try {
+    session = await loadSession(proc, deps, args);
+  } catch (error) {
+    return fail(stderr, error);
+  }
+  if (!session.items.length) {
+    stdout.write('nothing to review\n');
+    return 0;
+  }
+  if (!proc.stdin.isTTY || !stdout.isTTY) {
+    stderr.write('reslop: interactive terminal required\n');
+    return 1;
+  }
+  return session.startUi();
+};
+
+module.exports = {
+  run,
+  parseArgv,
+  resolveScope,
+  looksLikeRev,
+  selectChangeSource,
+  errorMessage,
+};

package/lib/clipboard.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const { spawnSync } = require('node:child_process');
+
+const { ESC } = require('./ansi.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');
+  return `${ESC}]52;c;${b64}\x07`;
+};
+
+const runClip = (cmd, args, text) => {
+  const result = spawnSync(cmd, args, {
+    input: text,
+    encoding: 'utf8',
+    timeout: CLIP_TIMEOUT_MS,
+  });
+  if (result.error) return false;
+  return result.status === 0;
+};
+
+const copyText = (text, stdout) => {
+  if (!text) return false;
+  let ok = false;
+  if (stdout && stdout.write) {
+    stdout.write(osc52(text));
+    ok = true;
+  }
+  for (const tool of CLIP_TOOLS) {
+    if (runClip(tool.cmd, tool.args, text)) return true;
+  }
+  return ok;
+};
+
+module.exports = { osc52, copyText, runClip };