reslop 0.3.2 → 0.3.3

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## [Unreleased][unreleased]
 
+## [0.3.3][] - 2026-10-16
+
+- Add Junie by JetBrains support
+- Add GitHub Copilot support
+- Add Pi coding agent support with its ACP adapter
+- Add Kiro by AWS support, installed with its vendor script
+- Add Cline support
+- Add Windsurf support through Devin CLI, its current agent
+- Add Kilo Code support
+- Show agents in two columns on the dashboard, without models
+
 ## [0.3.2][] - 2026-10-15
 
 - Communicate with agents over the Agent Client Protocol instead of CLI
@@ -213,7 +224,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.3.2...HEAD
+[unreleased]: https://github.com/tshemsedinov/reslop/compare/v0.3.3...HEAD
+[0.3.3]: https://github.com/tshemsedinov/reslop/compare/v0.3.2...v0.3.3
 [0.3.2]: https://github.com/tshemsedinov/reslop/compare/v0.3.1...v0.3.2
 [0.3.1]: https://github.com/tshemsedinov/reslop/compare/v0.3.0...v0.3.1
 [0.3.0]: https://github.com/tshemsedinov/reslop/compare/v0.2.7...v0.3.0

package/README.md

@@ -25,13 +25,14 @@ Review → Plan → Repair → Verify
 - Auto-reload local diffs when files change, keeping the current screen
 - Import GitHub PR and GitLab MR review comments, and GitHub/GitLab issues, into tasks and the local plan
 - Commits list: brief and full, view a commit's diff, commit, update, amend, apply, edit, fixup, and delete
-- Branches: checkout, create, rebase, delete, pull, and push
+- Branches: checkout, create, rebase, delete, pull, and push; git worktrees as tiles above the branches
+- Pop-up menus on tables and controls
 - npm scripts and bins: run, edit, and reorder; double-click to run; clean logs older than 5 days
 - Reduced test and lint output for agents: failures and a short summary, not passing noise
 - Review, renew, audit and update npm dependencies in `package.json` and the lockfile
 - Auto-update reslop patch and minor releases; confirm a new major
 - Work with git, npm, and fetch in the background; run tests in the background while you review
-- Execute the plan in local agents over ACP: pick agent, model, and effort; watch progress; sessions, history, and continue or new runs
+- Execute the plan in local agents over ACP: pick agent, model, and effort; watch progress; sessions, history, and continue or new runs. The dashboard lists agents in two columns, without models
 - Agent defaults in `.reslop` (grouped settings sections)
 - Optional line numbers in diff and file views (`Ctrl+L`)
 
@@ -82,15 +83,22 @@ Reviews go in `.plan/YYYY-MM-DD-NN.md` with frontmatter `status`:
 
 reslop runs a plan in an agent over the [Agent Client Protocol](https://agentclientprotocol.com). An agent is listed as available when the command that serves ACP is on `PATH`:
 
-| Agent       | Command              | Install                                          |
-| ----------- | -------------------- | ------------------------------------------------ |
-| Claude Code | `claude-agent-acp`   | `npm i -g @agentclientprotocol/claude-agent-acp` |
-| Codex       | `codex-acp`          | `npm i -g @agentclientprotocol/codex-acp`        |
-| Cursor      | `cursor-agent acp`   | comes with the Cursor CLI                        |
-| OpenCode    | `opencode acp`       | `npm i -g opencode-ai`                           |
-| Antigravity | `agy_acp_server.par` | downloaded from the official ACP registry        |
-
-A missing agent shows what it needs, in the warning color; `i` on that row proposes installing it. npm adapters are installed globally, while Google Antigravity's official ACP runtime is downloaded from the ACP registry into reslop's user data directory. reslop also discovers that runtime on `PATH` and in Zed's registry directory. After confirmation, reslop lists the agent as soon as the install finishes and does not restart. [docs/acp-adapters.md](docs/acp-adapters.md) describes the integrations.
+| Agent       | Command              | Install                                           |
+| ----------- | -------------------- | ------------------------------------------------- |
+| Claude Code | `claude-agent-acp`   | `npm i -g @agentclientprotocol/claude-agent-acp`  |
+| Codex       | `codex-acp`          | `npm i -g @agentclientprotocol/codex-acp`         |
+| Cursor      | `cursor-agent acp`   | comes with the Cursor CLI                         |
+| OpenCode    | `opencode acp`       | `npm i -g opencode-ai`                            |
+| Antigravity | `agy_acp_server.par` | downloaded from the official ACP registry         |
+| Junie       | `junie --acp=true`   | `npm i -g @jetbrains/junie`                       |
+| Copilot     | `copilot --acp`      | `npm i -g @github/copilot`                        |
+| Pi          | `pi-acp` and `pi`    | `npm i -g pi-acp @earendil-works/pi-coding-agent` |
+| Kiro        | `kiro-cli acp`       | install script from cli.kiro.dev                  |
+| Cline       | `cline --acp`        | `npm i -g cline`                                  |
+| Windsurf    | `devin acp`          | install script from cli.devin.ai                  |
+| Kilo Code   | `kilo acp`           | `npm i -g @kilocode/cli`                          |
+
+A missing agent shows what it needs, in the warning color; `i` on that row proposes installing it. npm adapters are installed globally, together with the agent's own CLI when the adapter runs it and it is not on `PATH`, while Google Antigravity's official ACP runtime is downloaded from the ACP registry into reslop's user data directory. Windsurf is listed as `devin`: Cognition's Devin CLI is now the agent of Windsurf, and the Windsurf editor does not serve ACP. An agent CLI published with an install script, such as Kiro's or Devin's, is installed by running the vendor's script, and its command is also found in `~/.local/bin`. reslop also discovers that runtime on `PATH` and in Zed's registry directory. After confirmation, reslop lists the agent as soon as the install finishes and does not restart. [docs/acp-adapters.md](docs/acp-adapters.md) describes the integrations.
 
 Models are the ones the agent lists; efforts, context sizes, and fast mode are the ones it offers for the picked model. When a run ends, the session is set back to what it was, so the defaults of the agent's own CLI stay as they were. A run has nobody to ask, so reslop answers permission requests itself: edits inside the repository and `npm`, `npx`, `node`, `reslop`, and `git` commands, piped through read-only filters such as `grep` or `tail`, are allowed; everything else is refused.
 

package/lib/agents/agents.js

@@ -11,6 +11,7 @@ const { choiceOf } = models;
 const { startRun, probeSession } = require('./run.js');
 const registry = require('./registry.js');
 const { installedRegistryAgent } = registry;
+const { localBin, scriptUrl } = require('./script.js');
 const { resolveGitDirs } = require('../git/dir.js');
 
 const CODEX_SANDBOX = 'sandbox_workspace_write';
@@ -58,9 +59,15 @@ const defineAgent = (spec) => ({
   title: spec.title,
   commands: spec.commands,
   package: spec.package ?? '',
+  // The cli of the agent that an adapter starts, as { bin, package }
+  requires: spec.requires ?? null,
   registry: spec.registry ?? '',
+  // The install scripts of the vendor, as { unix, win } https urls
+  script: spec.script ?? null,
   installLabel: spec.installLabel ?? '',
   hint: spec.hint ?? '',
+  // A program of the vendor that does not serve ACP, as { bin, hint }
+  related: spec.related ?? null,
   mode: spec.mode ?? '',
   env: spec.env ?? (() => ({})),
 });
@@ -104,8 +111,73 @@ const AGENTS = [
     registry: 'antigravity-acp',
     installLabel: 'Google Antigravity ACP',
     hint: 'install Google Antigravity ACP',
+    related: {
+      bin: 'agy',
+      hint: 'agy installed; install Google Antigravity ACP',
+    },
     env: antigravityEnv,
   }),
+  defineAgent({
+    id: 'junie',
+    title: 'Junie',
+    commands: [['junie', '--acp=true']],
+    package: '@jetbrains/junie',
+  }),
+  defineAgent({
+    id: 'copilot',
+    title: 'Copilot',
+    commands: [['copilot', '--acp']],
+    package: '@github/copilot',
+  }),
+  defineAgent({
+    id: 'pi',
+    title: 'Pi',
+    commands: [['pi-acp']],
+    package: 'pi-acp',
+    requires: { bin: 'pi', package: '@earendil-works/pi-coding-agent' },
+  }),
+  defineAgent({
+    id: 'kiro',
+    title: 'Kiro',
+    commands: [['kiro-cli', 'acp', '--agent-engine=v3']],
+    script: {
+      unix: 'https://cli.kiro.dev/install',
+      win: 'https://cli.kiro.dev/install.ps1',
+    },
+    installLabel: 'Kiro CLI from cli.kiro.dev',
+    hint: 'install the Kiro CLI from cli.kiro.dev',
+  }),
+  defineAgent({
+    id: 'cline',
+    title: 'Cline',
+    commands: [['cline', '--acp']],
+    package: 'cline',
+  }),
+  // Windsurf's agent is now the Devin CLI of Cognition; the editor has no ACP
+  defineAgent({
+    id: 'devin',
+    title: 'Devin for Windsurf',
+    commands: [['devin', 'acp']],
+    script: {
+      unix: 'https://cli.devin.ai/install.sh',
+      win: 'https://static.devin.ai/cli/setup.ps1',
+    },
+    installLabel: 'Devin CLI from cli.devin.ai',
+    hint: 'install the Devin CLI, the agent of Windsurf',
+    related: {
+      bin: 'windsurf',
+      hint: 'windsurf installed; install the Devin CLI',
+    },
+  }),
+  defineAgent({
+    id: 'kilo',
+    title: 'Kilo Code',
+    commands: [
+      ['kilo', 'acp'],
+      ['kilocode', 'acp'],
+    ],
+    package: '@kilocode/cli',
+  }),
 ];
 
 const agentSpec = (id) => AGENTS.find((spec) => spec.id === id) ?? null;
@@ -139,8 +211,8 @@ const isBin = (file) => {
   }
 };
 
-const findBin = (name, env = process.env) => {
-  for (const dir of pathDirs(env)) {
+const findIn = (dirs, name, env) => {
+  for (const dir of dirs) {
     for (const file of binNames(name, env)) {
       const full = path.join(dir, file);
       if (isBin(full)) return full;
@@ -149,9 +221,19 @@ const findBin = (name, env = process.env) => {
   return '';
 };
 
+const findBin = (name, env = process.env) => findIn(pathDirs(env), name, env);
+
+// An install script may put its command in a directory missing from PATH
+const commandDirs = (spec, env) => {
+  const dirs = pathDirs(env);
+  const local = spec.script ? localBin(env) : '';
+  return local && !dirs.includes(local) ? [...dirs, local] : dirs;
+};
+
 const findCommand = (spec, env) => {
+  const dirs = commandDirs(spec, env);
   for (const [name, ...args] of spec.commands) {
-    const bin = findBin(name, env);
+    const bin = findIn(dirs, name, env);
     if (bin) return { bin, args };
   }
   if (spec.registry) {
@@ -161,27 +243,44 @@ const findCommand = (spec, env) => {
   return { bin: '', args: [] };
 };
 
-// What a missing agent takes: an npm package or an official registry binary
-const installHint = (spec, env) => {
+// npm packages still missing: the adapter and the cli of the agent it starts
+const missingPackages = (spec, env, found) => {
+  const names = [];
+  if (!found.bin && spec.package) names.push(spec.package);
+  const cli = spec.requires;
+  if (cli && !findBin(cli.bin, env)) names.push(cli.package);
+  return names;
+};
+
+// What a missing agent takes: npm packages, a registry binary, or a script
+const installHint = (spec, env, packages) => {
+  if (packages.length) return `npm i -g ${packages.join(' ')}`;
   if (spec.package) return `npm i -g ${spec.package}`;
-  if (spec.registry && findBin('agy', env)) {
-    return 'agy installed; install Google Antigravity ACP';
-  }
+  const { related } = spec;
+  if (related && findBin(related.bin, env)) return related.hint;
   return spec.hint;
 };
 
-const detectAgents = (env = process.env) =>
-  AGENTS.map((spec) => ({
+const detectAgent = (spec, env) => {
+  const found = findCommand(spec, env);
+  const packages = missingPackages(spec, env, found);
+  const command = packages.length ? { bin: '', args: [] } : found;
+  return {
     id: spec.id,
     name: spec.name,
     spec,
-    package: spec.package,
-    installable: Boolean(spec.package || spec.registry),
+    package: packages.join(' ') || spec.package,
+    packages,
+    installable: Boolean(spec.package || spec.registry || spec.script),
     installLabel: spec.installLabel,
-    hint: installHint(spec, env),
+    hint: installHint(spec, env, packages),
     catalog: null,
-    ...findCommand(spec, env),
-  }));
+    ...command,
+  };
+};
+
+const detectAgents = (env = process.env) =>
+  AGENTS.map((spec) => detectAgent(spec, env));
 
 const listModels = (row, options = {}) => {
   if (!row || !row.bin) return Promise.resolve(null);
@@ -239,34 +338,44 @@ const buildLaunch = (row, picked, reviewPath, cwd, sessionId = '') => {
   return launch;
 };
 
+// A helper of reslop downloads a registry binary or runs a vendor script
+const helperInstall = (row, installer, file, arg) => ({
+  installer,
+  cmd: process.execPath,
+  args: [path.join(__dirname, file), arg],
+  command: `install ${row.spec.installLabel || row.name}`,
+});
+
 // The package lands in the global prefix of npm, where PATH finds its command
+const installCommand = (row) => {
+  const { spec } = row;
+  if (spec.registry) {
+    return helperInstall(row, 'registry', 'registry.js', spec.registry);
+  }
+  if (spec.script) {
+    const url = scriptUrl(spec.script);
+    return helperInstall(row, 'script', 'script.js', url);
+  }
+  const names = row.packages ?? [spec.package].filter(Boolean);
+  if (!names.length) return null;
+  const args = ['install', '--global', ...names];
+  const command = `npm ${args.join(' ')}`;
+  return { installer: 'npm', cmd: npmBin(), args, command };
+};
+
 const buildInstall = (row) => {
   if (!row) return { ok: false, error: 'no agent' };
   if (row.bin) return { ok: false, error: 'installed' };
-  const name = row.spec.package;
-  const registryId = row.spec.registry;
-  if (!name && !registryId) {
-    return { ok: false, error: row.hint || 'no installer' };
-  }
-  const npmArgs = name ? ['install', '--global', name] : [];
-  const args = registryId
-    ? [path.join(__dirname, 'registry.js'), registryId]
-    : npmArgs;
-  const cmd = registryId ? process.execPath : npmBin();
-  const command = registryId
-    ? `install ${row.spec.installLabel || row.name}`
-    : `npm ${npmArgs.join(' ')}`;
+  const install = installCommand(row);
+  if (!install) return { ok: false, error: row.hint || 'no installer' };
   return {
     ok: true,
     id: row.id,
     name: row.name,
     kind: 'install',
-    installer: registryId ? 'registry' : 'npm',
-    cmd,
-    args,
+    ...install,
     plan: '',
     session: '',
-    command,
   };
 };
 

package/lib/agents/script.js

@@ -0,0 +1,93 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawn } = require('node:child_process');
+
+// Where the install scripts of agent CLIs put their command
+const localBin = (env = process.env) => {
+  const home = env.HOME || env.USERPROFILE;
+  return home ? path.join(home, '.local', 'bin') : '';
+};
+
+const httpsUrl = (href) => {
+  if (!href) throw new Error('no install script for this platform');
+  const url = new URL(href);
+  if (url.protocol !== 'https:') {
+    throw new Error('install script must use https');
+  }
+  return url.href;
+};
+
+// The script a vendor publishes for this platform
+const scriptUrl = (script, platform = process.platform) =>
+  httpsUrl(platform === 'win32' ? script.win : script.unix);
+
+const shellOf = (file, platform) => {
+  if (platform !== 'win32') return ['bash', [file]];
+  const args = ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', file];
+  return ['powershell.exe', args];
+};
+
+// The script finds the directory it installs to on PATH and does not fail
+const scriptEnv = (env) => {
+  const bin = localBin(env);
+  const key = Object.keys(env).find((name) => name.toUpperCase() === 'PATH');
+  const name = key ?? 'PATH';
+  const dirs = `${env[name] ?? ''}`.split(path.delimiter).filter(Boolean);
+  if (!bin || dirs.includes(bin)) return { ...env };
+  return { ...env, [name]: [bin, ...dirs].join(path.delimiter) };
+};
+
+const runFile = (cmd, args, env, spawnImpl) =>
+  new Promise((resolve, reject) => {
+    const stdio = ['ignore', 'inherit', 'inherit'];
+    const child = spawnImpl(cmd, args, { env, stdio, windowsHide: true });
+    child.on('error', reject);
+    child.on('close', (code) => resolve(code ?? 1));
+  });
+
+const runScript = async (url, options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  if (typeof fetchImpl !== 'function') {
+    throw new Error('fetch is not available');
+  }
+  const env = options.env ?? process.env;
+  const platform = options.platform ?? process.platform;
+  const log = options.log ?? (() => {});
+  const href = httpsUrl(url);
+  log(`Downloading ${href}…`);
+  const response = await fetchImpl(href);
+  if (!response || !response.ok) {
+    const status = response ? ` (${response.status})` : '';
+    throw new Error(`download failed${status}`);
+  }
+  const text = await response.text();
+  const dir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'reslop-'));
+  try {
+    const name = platform === 'win32' ? 'install.ps1' : 'install.sh';
+    const file = path.join(dir, name);
+    await fs.promises.writeFile(file, text, { mode: 0o600 });
+    const [cmd, args] = shellOf(file, platform);
+    const spawnImpl = options.spawn ?? spawn;
+    return await runFile(cmd, args, scriptEnv(env), spawnImpl);
+  } finally {
+    await fs.promises.rm(dir, { recursive: true, force: true });
+  }
+};
+
+const main = async () => {
+  try {
+    process.exitCode = await runScript(process.argv[2], {
+      log: (line) => process.stdout.write(`${line}\n`),
+    });
+  } catch (error) {
+    process.stderr.write(`${error.message}\n`);
+    process.exitCode = 1;
+  }
+};
+
+if (require.main === module) void main();
+
+module.exports = { localBin, scriptUrl, scriptEnv, runScript };

package/lib/render/agents.js

@@ -21,6 +21,7 @@ const { paintField, queryTones, fieldHit } = require('./field.js');
 
 const BUBBLE = '●';
 const BUBBLE_GAP = 1;
+const COLUMN_GAP = 2;
 const BUBBLE_PHASE = ['key', 'add', 'sha', 'warn'];
 const PAD_W = 2;
 const TAIL = 2;
@@ -642,13 +643,29 @@ const agentLead = (item, frame) => {
   return cellSegs(segs);
 };
 
-const agentName = (item) => {
+// The last column clips its names when the tile is narrow
+const agentCells = (item, frame, last) => {
+  if (!item) return [];
   const tone = item.bin ? 'text' : 'muted';
-  const name = flexCell(item.name, tone);
+  const name = last ? flexCell(item.name, tone) : cell(item.name, tone);
   name.gap = BUBBLE_GAP;
-  return name;
+  return [agentLead(item, frame), name];
 };
 
+// Two columns while both fit their widest agent, else one
+const columnCount = (items, width) => {
+  let lead = 0;
+  let name = 0;
+  for (const item of items) {
+    const sessions = item.running ? ` ${item.running}` : '';
+    lead = Math.max(lead, visibleWidth(`${BUBBLE}${sessions}`));
+    name = Math.max(name, visibleWidth(item.name));
+  }
+  const entry = lead + BUBBLE_GAP + name;
+  return entry * 2 + COLUMN_GAP <= width ? 2 : 1;
+};
+
+// Agents fill the left column first
 const agentsBlock = (model, width, height, ctx, tile) => {
   const data = model.agents;
   if (!data || !data.ready) return waiting('detecting agents…');
@@ -656,13 +673,20 @@ const agentsBlock = (model, width, height, ctx, tile) => {
   const titleLine = titleAside(tile, aside, width);
   const items = data.items ?? [];
   if (!items.length) return notice('no agents', titleLine);
-  const shown = items.slice(0, Math.max(0, height));
-  const rows = shown.map((item) => [
-    agentLead(item, ctx.frame),
-    agentName(item),
-    cell(item.bin ? item.model : 'missing', item.bin ? 'sha' : 'muted', 'r'),
-  ]);
-  return { titleLine, lines: tableLines(rows, width) };
+  const columns = columnCount(items, width);
+  const perColumn = Math.ceil(items.length / columns);
+  const count = Math.min(Math.max(0, height), perColumn);
+  const rows = [];
+  for (let i = 0; i < count; i++) {
+    const left = agentCells(items[i], ctx.frame, columns === 1);
+    if (columns === 1) {
+      rows.push(left);
+      continue;
+    }
+    const right = agentCells(items[i + count], ctx.frame, true);
+    rows.push([...left, ...right]);
+  }
+  return { titleLine, lines: tableLines(rows, width, COLUMN_GAP) };
 };
 
 module.exports = { paintBodyAgents, agentsBlock };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reslop",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "Interactive code review and repair planning for AI-assisted changes",
   "keywords": [
     "code-review",