reslop 0.3.1 → 0.3.3

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/agents/transcript.js

@@ -0,0 +1,143 @@
+'use strict';
+
+const { isHashObject } = require('metautil');
+
+const TITLE_MAX = 200;
+const TOOL_MARK = { completed: '✔', failed: '✖' };
+const RUNNING_MARK = '▸';
+const THOUGHT_MARK = '│ ';
+const WRITE_KINDS = ['edit', 'delete', 'move'];
+const CHUNK_KIND = new Map([
+  ['agent_message_chunk', 'text'],
+  ['agent_thought_chunk', 'thought'],
+]);
+
+const oneLine = (text) => {
+  const line = `${text ?? ''}`.replace(/\s+/g, ' ').trim();
+  return line.length > TITLE_MAX ? `${line.slice(0, TITLE_MAX - 1)}…` : line;
+};
+
+const chunkText = (content) => {
+  if (!isHashObject(content)) return '';
+  return content.type === 'text' ? `${content.text ?? ''}` : '';
+};
+
+const quoted = (text) =>
+  text
+    .replace(/\n+$/, '')
+    .split('\n')
+    .map((line) => `${THOUGHT_MARK}${line}`)
+    .join('\n');
+
+const rootPrefix = (root) => {
+  const slash = `${root ?? ''}`.replaceAll('\\', '/');
+  const trimmed = slash.replace(/\/+$/, '');
+  return trimmed ? `${trimmed}/` : '';
+};
+
+const FACE = {
+  text: (block) => block.text.replace(/\n+$/, ''),
+  thought: (block) => quoted(block.text),
+  note: (block) => `△ ${block.text}`,
+  tool: (block) => {
+    const title = block.title || block.tool || 'tool';
+    if (block.denied) return `${TOOL_MARK.failed} denied: ${title}`;
+    return `${TOOL_MARK[block.status] ?? RUNNING_MARK} ${title}`;
+  },
+};
+
+// The session updates of a run as the text its log shows
+class Transcript {
+  constructor(root = '') {
+    // Agents name files by full path: inside the repository it is noise
+    this.prefix = rootPrefix(root);
+    this.blocks = [];
+    this.tools = new Map();
+    this.files = new Set();
+    this.tokens = null;
+    this.cache = null;
+  }
+
+  add(block) {
+    this.blocks.push(block);
+    this.cache = null;
+    return block;
+  }
+
+  note(text) {
+    const line = oneLine(text);
+    if (line) this.add({ kind: 'note', text: line });
+  }
+
+  fail(error) {
+    const text = `${(error && error.message) || error || 'failed'}`.trim();
+    this.add({ kind: 'text', text: `✖ ${text}` });
+  }
+
+  write(kind, text) {
+    if (!text) return;
+    const last = this.blocks.at(-1);
+    if (last && last.kind === kind) last.text += text;
+    else this.add({ kind, text });
+    this.cache = null;
+  }
+
+  title(text) {
+    const line = `${text ?? ''}`.replaceAll('\\', '/');
+    const stripped = this.prefix ? line.replaceAll(this.prefix, '') : line;
+    return oneLine(stripped);
+  }
+
+  deny(call) {
+    this.tool(call).denied = true;
+  }
+
+  tool(update) {
+    const id = `${update.toolCallId ?? ''}`;
+    const known = this.tools.get(id);
+    const block = known ?? this.add({ kind: 'tool', title: '', status: '' });
+    if (!known) this.tools.set(id, block);
+    const { title, status, kind } = update;
+    if (typeof title === 'string') block.title = this.title(title);
+    if (typeof status === 'string') block.status = status;
+    if (typeof kind === 'string') block.tool = kind;
+    this.cache = null;
+    if (!WRITE_KINDS.includes(block.tool)) return block;
+    const listed = Array.isArray(update.locations) ? update.locations : [];
+    for (const location of listed) {
+      const file = isHashObject(location) ? location.path : '';
+      if (file) this.files.add(file);
+    }
+    return block;
+  }
+
+  update(update) {
+    if (!isHashObject(update)) return;
+    const type = update.sessionUpdate;
+    const kind = CHUNK_KIND.get(type);
+    if (kind) return void this.write(kind, chunkText(update.content));
+    if (type === 'tool_call' || type === 'tool_call_update') {
+      return void this.tool(update);
+    }
+    if (type !== 'usage_update') return;
+    if (Number.isFinite(update.used)) this.tokens = update.used;
+  }
+
+  text() {
+    if (this.cache !== null) return this.cache;
+    let out = '';
+    let prev = '';
+    for (const block of this.blocks) {
+      const face = FACE[block.kind](block);
+      if (!face) continue;
+      const joined = prev === 'tool' && block.kind === 'tool';
+      if (out) out += joined ? '\n' : '\n\n';
+      out += face;
+      prev = block.kind;
+    }
+    this.cache = out ? `${out}\n` : '';
+    return this.cache;
+  }
+}
+
+module.exports = { Transcript };

package/lib/cli.js

@@ -16,6 +16,7 @@ const {
 } = require('./source/capabilities.js');
 const { runCapture } = require('./report/run.js');
 const { workspaceFromArgs } = require('./dashboard/workspace.js');
+const { expandWorkspace } = require('./dashboard/worktrees.js');
 
 const HEX_REV = /^[0-9a-f]{4,40}$/i;
 const HEAD_REV = /^HEAD([~^].*)?$/i;
@@ -72,7 +73,7 @@ const localOptions = async (deps, args, selected, cwd) => {
       rev: null,
       capabilities,
       startPane: 'repos',
-      workspace: found,
+      workspace: await expandWorkspace(found),
       repoName: path.basename(found.root),
     };
   }

package/lib/common/process.js

@@ -6,6 +6,7 @@ const IS_WIN = process.platform === 'win32';
 const INSTALL_MS = 120000;
 const DEFAULT_ENCODING = 'utf8';
 const DEFAULT_MAX_BUFFER = 32 * 1024 * 1024;
+const CMD_SAFE = /^[\w./:=@+-]+$/;
 
 const npmBin = () => (IS_WIN ? 'npm.cmd' : 'npm');
 
@@ -14,6 +15,28 @@ const spawnBase = (extra = {}) => ({ windowsHide: true, ...extra });
 const npmOpts = (extra = {}, platform = process.platform) =>
   spawnBase({ shell: platform === 'win32', ...extra });
 
+const quoteCmdArg = (arg) => {
+  const text = `${arg}`;
+  if (text && CMD_SAFE.test(text)) return text;
+  const escaped = text.replaceAll('"', '""').replaceAll('%', '"%"');
+  return `"${escaped}"`;
+};
+
+const winCommand = (program, args) => {
+  const list = args ?? [];
+  const parts = [program, ...list].map(quoteCmdArg);
+  return `"${parts.join(' ')}"`;
+};
+
+// cmd.exe quoting, not Node's shell:true join, which splits a quoted -e script
+const spawnCmd = (cmd, args, options = {}) => {
+  if (!IS_WIN || options.shell !== true) return spawn(cmd, args, options);
+  const shell = process.env.comspec || 'cmd.exe';
+  const line = winCommand(cmd, args);
+  const opts = { ...options, windowsVerbatimArguments: true, shell: false };
+  return spawn(shell, ['/d', '/s', '/c', line], opts);
+};
+
 const codeError = (message, code) =>
   Object.assign(new Error(message), { code });
 
@@ -98,7 +121,7 @@ const runProc = (cmd, args, options = {}) =>
     if (options.shell) spawnOpts.shell = true;
     let child = null;
     try {
-      child = spawn(cmd, args, spawnBase(spawnOpts));
+      child = spawnCmd(cmd, args, spawnBase(spawnOpts));
     } catch (error) {
       resolve(procResult({ error }));
     }
@@ -112,6 +135,8 @@ module.exports = {
   npmBin,
   spawnBase,
   npmOpts,
+  winCommand,
+  spawnCmd,
   abortError,
   isAbort,
   runProc,

package/lib/dashboard/git.js

@@ -5,6 +5,7 @@ const path = require('node:path');
 const { readText } = require('../common/utilities.js');
 
 const { runGit } = require('../git/worktree.js');
+const { commitCount, gitDirPath } = require('../git/local.js');
 
 const UNIT = '\x1f';
 const RECENT_COUNT = 8;
@@ -97,9 +98,18 @@ const rebaseState = (gitDir) => {
   return null;
 };
 
+const probeText = (top, name) => {
+  if (name === 'dir') return gitDirPath(top);
+  if (name === 'total') {
+    const counted = commitCount(top);
+    if (counted !== '') return counted;
+  }
+  return gitText(top, PROBES[name]);
+};
+
 const readGitSummary = async (top) => {
   const names = Object.keys(PROBES);
-  const read = (name) => gitText(top, PROBES[name]);
+  const read = (name) => probeText(top, name);
   const texts = await Promise.all(names.map(read));
   const probes = {};
   for (let i = 0; i < names.length; i++) probes[names[i]] = texts[i];

package/lib/dashboard/reports.js

@@ -0,0 +1,80 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+const { MANIFEST, LOCKFILE } = require('../deps/deps.js');
+const { collectReport } = require('../git/deps.js');
+
+const REPORT_TTL_MS = 10 * 60 * 1000;
+const MODULES_LOCK = path.join('node_modules', '.package-lock.json');
+
+const answers = new Map();
+
+const hashOf = (file) => {
+  try {
+    const bytes = fs.readFileSync(file);
+    return crypto.createHash('sha1').update(bytes).digest('hex');
+  } catch {
+    return '';
+  }
+};
+
+const stampOf = (file) => {
+  try {
+    const stat = fs.statSync(file);
+    return `${stat.mtimeMs}:${stat.size}`;
+  } catch {
+    return '';
+  }
+};
+
+// `npm audit` reads the lockfile only, so equal lockfiles have equal answers
+// in every worktree of a repository
+const auditKey = (dir) => {
+  const hash = hashOf(path.join(dir, LOCKFILE));
+  return hash ? `audit:${hash}` : '';
+};
+
+// `npm outdated` reads what is installed, so it is kept for the directory
+const outdatedKey = (dir) => {
+  const files = [MANIFEST, LOCKFILE, MODULES_LOCK];
+  const stamps = files.map((file) => stampOf(path.join(dir, file)));
+  return `outdated:${path.resolve(dir)}:${stamps.join(':')}`;
+};
+
+// The answer is asked of npm once while the files stay as they are, however
+// many times the tiles are read: npm goes to the network
+const remembered = (key, collect, now = Date.now()) => {
+  if (!key) return collect();
+  const hit = answers.get(key);
+  if (hit && now - hit.at < REPORT_TTL_MS) return hit.promise;
+  const promise = collect();
+  answers.set(key, { at: now, promise });
+  promise.catch(() => answers.delete(key));
+  return promise;
+};
+
+const sizeOf = async (collect, dir, kind) => {
+  const report = await collect(dir, kind);
+  return report ? report.size : 0;
+};
+
+const reportCounts = async (dir, collect = collectReport) => {
+  const [audit, outdated] = await Promise.all([
+    remembered(auditKey(dir), () => sizeOf(collect, dir, 'audit')),
+    remembered(outdatedKey(dir), () => sizeOf(collect, dir, 'outdated')),
+  ]);
+  return { audit, outdated };
+};
+
+const forgetReports = () => answers.clear();
+
+module.exports = {
+  auditKey,
+  outdatedKey,
+  remembered,
+  reportCounts,
+  forgetReports,
+};

package/lib/dashboard/watch.js

@@ -6,6 +6,7 @@ const path = require('node:path');
 const runs = require('../runs/runs.js');
 const { isRunsRel } = runs;
 const { REVIEW_DIR, posixRel } = require('../common/files.js');
+const { resolveGitDirs } = require('../git/dir.js');
 
 const DEBOUNCE_MS = 200;
 const UNKNOWN_PATH = '.';
@@ -42,7 +43,13 @@ const ignoredName = (name) => {
   return suffix || backup || store;
 };
 
-const ignoredGitRel = ([, name = '', sub]) => {
+// Linked worktrees keep their HEAD and index in `.git/worktrees/<name>`
+const ignoredLinkedRel = ([, , , leaf = '']) =>
+  leaf !== '' && !GIT_WATCH_NAMES.includes(leaf) && leaf !== 'logs';
+
+const ignoredGitRel = (parts) => {
+  const [, name = '', sub] = parts;
+  if (name === 'worktrees') return ignoredLinkedRel(parts);
   if (name === 'logs' && sub === 'HEAD') return false;
   return name !== '' && !GIT_WATCH_NAMES.includes(name);
 };
@@ -53,7 +60,8 @@ const ignoredRel = (rel) => {
   if (norm === MODULES_STAMP) return false;
   const parts = norm.split('/');
   if (parts.some((part) => SKIP_DIRS.includes(part))) return true;
-  if (parts[0] === '.git') return ignoredGitRel(parts);
+  const gitAt = parts.indexOf('.git');
+  if (gitAt >= 0) return ignoredGitRel(parts.slice(gitAt));
   return ignoredName(parts[parts.length - 1]);
 };
 
@@ -150,15 +158,35 @@ class DiskWatcher {
     this.closed = false;
     const scopes = options.paths?.length ? options.paths : ['.'];
     for (const spec of scopes) this.watchScope(spec);
-    const gitDir = path.resolve(this.root, '.git');
-    this.watchOne(gitDir);
-    this.watchOne(path.join(gitDir, 'refs'));
-    this.watchOne(path.join(gitDir, 'logs'));
+    this.watchGit();
     this.watchOne(path.resolve(this.root, runs.logDir('.')));
     this.watchOne(path.resolve(this.root, runs.runsDir('.')));
     this.watchOne(path.resolve(this.root, REVIEW_DIR));
   }
 
+  // `.git` of a linked worktree is a file, its state lives in other places
+  watchGit() {
+    const dirs = resolveGitDirs(this.root);
+    this.gitBases = dirs && dirs.linked ? [dirs.gitDir, dirs.commonDir] : [];
+    const { gitDir, commonDir } = dirs ?? {};
+    const dot = path.resolve(this.root, '.git');
+    for (const base of new Set([gitDir ?? dot, commonDir ?? dot])) {
+      this.watchOne(base);
+      this.watchOne(path.join(base, 'refs'));
+      this.watchOne(path.join(base, 'logs'));
+    }
+  }
+
+  // Events of the git directories are reported as paths of `.git`
+  relOf(full) {
+    for (const base of this.gitBases) {
+      const inside = path.relative(base, full);
+      if (inside.startsWith('..') || path.isAbsolute(inside)) continue;
+      return posixRel(path.join('.git', inside));
+    }
+    return posixRel(path.relative(this.root, full));
+  }
+
   schedule(key, fire) {
     if (this.closed || !fire) return;
     this.clearTimer(key);
@@ -212,11 +240,17 @@ class DiskWatcher {
 
   onEvent(dir, eventType, filename) {
     if (this.closed) return;
+    // Windows keeps reporting a directory after it was deleted, forever
+    if (!hasFile(dir)) {
+      const rel = this.relOf(dir) || UNKNOWN_PATH;
+      this.close();
+      if (this.onPaths) this.onPaths([rel]);
+      return;
+    }
     const name = filename ? `${filename}` : '';
     let rel = '';
     if (name) {
-      const full = path.join(dir, name);
-      rel = posixRel(path.relative(this.root, full));
+      rel = this.relOf(path.join(dir, name));
     }
     const wanted = this.files.has(rel);
     if (isRunsRel(rel)) {
@@ -253,6 +287,7 @@ class DiskWatcher {
       const watcher = fs.watch(target, options, (eventType, filename) => {
         this.onEvent(target, eventType, filename);
       });
+      watcher.unref();
       watcher.on('error', () => {});
       this.watched.add(target);
       this.watchers.push(watcher);

package/lib/dashboard/workspace.js

@@ -6,7 +6,8 @@ const path = require('node:path');
 const { REVIEW_DIR } = require('../common/files.js');
 const review = require('../review/review.js');
 const { listReviewNames, latestReviewName, loadReview, noteCounts } = review;
-const { countUntrackedAdded } = require('../git/worktree.js');
+const { diffCounts } = require('../git/worktree.js');
+const { branchOf, commitCount, worktreeRoot } = require('../git/local.js');
 const { gitText, countOf } = require('./git.js');
 const { runName } = require('./model.js');
 const { readRuns } = require('../runs/runs.js');
@@ -87,29 +88,26 @@ const sumNumstat = (text) => {
   return { added, removed };
 };
 
-const readNumstat = async (dir, cached) => {
-  const stagedArgs = ['diff', '--cached', '--numstat'];
-  const openArgs = ['diff', '--numstat'];
-  const args = cached ? stagedArgs : openArgs;
-  return sumNumstat(await gitText(dir, args));
+const readDiffStat = async (dir) => {
+  try {
+    return await diffCounts(dir);
+  } catch {
+    return emptyDiff();
+  }
 };
 
-const readDiffStat = async (dir) => {
-  const [staged, open, untracked] = await Promise.all([
-    readNumstat(dir, true),
-    readNumstat(dir, false),
-    countUntrackedAdded(dir),
-  ]);
-  return {
-    stagedAdded: staged.added,
-    unstagedAdded: open.added + untracked,
-    stagedRemoved: staged.removed,
-    unstagedRemoved: open.removed,
-  };
+const countCommits = async (dir) => {
+  const counted = commitCount(dir);
+  if (counted !== '') return countOf(counted);
+  return countOf(await gitText(dir, ['rev-list', '--count', 'HEAD']));
 };
 
-const countCommits = async (dir) =>
-  countOf(await gitText(dir, ['rev-list', '--count', 'HEAD']));
+// Empty when HEAD is detached
+const currentBranchName = async (dir) => {
+  const root = worktreeRoot(dir);
+  if (root) return branchOf(root);
+  return gitText(dir, ['symbolic-ref', '--short', '-q', 'HEAD']);
+};
 
 const taskStats = (dir) => {
   const latest = latestReviewName(listReviewNames(dir));
@@ -146,6 +144,7 @@ module.exports = {
   sumNumstat,
   readDiffStat,
   countCommits,
+  currentBranchName,
   taskStats,
   pickRun,
 };