reslop 0.3.1 → 0.3.2

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,
 };

package/lib/dashboard/worktrees.js

@@ -0,0 +1,145 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { posixRel } = require('../common/files.js');
+const linked = require('../git/linked.js');
+const { listWorktrees, dirKey } = linked;
+const { resolveGitDirs } = require('../git/dir.js');
+const { workspaceAt } = require('./workspace.js');
+
+const HEAD_LENGTH = 7;
+const UNSAFE_NAME = /[\\/:*?"<>|\s]+/g;
+
+const isDir = (dir) => {
+  try {
+    return fs.statSync(dir).isDirectory();
+  } catch {
+    return false;
+  }
+};
+
+// Inside the folder a worktree is named by its directory, outside by its path
+const nameOf = (root, dir, taken) => {
+  const rel = posixRel(path.relative(root, dir));
+  const inside = rel && !rel.startsWith('..') && !path.isAbsolute(rel);
+  const plain = inside ? rel : path.basename(dir);
+  return taken.has(plain) ? dir : plain;
+};
+
+const plainRow = (repo) => ({
+  name: repo.name,
+  dir: repo.dir,
+  group: repo.name,
+  main: true,
+  linked: false,
+  branch: '',
+  head: '',
+  detached: false,
+  locked: false,
+});
+
+const entryRow = (root, entry, taken) => {
+  const name = nameOf(root, entry.path, taken);
+  return {
+    name,
+    dir: entry.path,
+    group: name,
+    main: entry.main,
+    linked: !entry.main,
+    branch: entry.branch,
+    head: entry.head.slice(0, HEAD_LENGTH),
+    detached: entry.detached,
+    locked: entry.locked,
+  };
+};
+
+const usable = (entry) => !entry.bare && !entry.prunable && isDir(entry.path);
+
+// The main one first, the linked ones by their directory name
+const inOrder = (entries) => {
+  const main = entries.filter((entry) => entry.main);
+  const rest = entries.filter((entry) => !entry.main);
+  const dirName = (entry) => path.basename(entry.path);
+  rest.sort((a, b) => dirName(a).localeCompare(dirName(b), 'en'));
+  return [...main, ...rest];
+};
+
+// The repositories of the folder with all their worktrees, one group each:
+// the main worktree first and the linked ones after it
+const expandWorkspace = async (info) => {
+  const seen = new Set();
+  const taken = new Set();
+  const repos = [];
+  const lists = await Promise.all(info.repos.map((r) => listWorktrees(r.dir)));
+  // Git reports real paths; a directory that was found keeps the path it
+  // was found by, which may go through a link
+  const found = new Map(info.repos.map((r) => [dirKey(r.dir), r.dir]));
+  for (const [index, repo] of info.repos.entries()) {
+    if (seen.has(dirKey(repo.dir))) continue;
+    const rows = inOrder(lists[index].filter(usable));
+    if (!rows.length) {
+      seen.add(dirKey(repo.dir));
+      taken.add(repo.name);
+      repos.push(plainRow(repo));
+      continue;
+    }
+    let group = '';
+    for (const entry of rows) {
+      seen.add(dirKey(entry.path));
+      const where = found.get(dirKey(entry.path)) ?? entry.path;
+      const row = entryRow(info.root, { ...entry, path: where }, taken);
+      group ||= row.name;
+      taken.add(row.name);
+      repos.push({ ...row, group });
+    }
+  }
+  return { ...info, repos };
+};
+
+// A folder of repositories, or the worktrees of one repository
+// The worktrees of a repository are asked of any of them that is left
+const readWorkspace = async (info, rows = []) => {
+  if (info.derived) {
+    const row = rows.find((it) => isDir(it.dir));
+    const seed = row ? [{ name: row.name, dir: row.dir }] : info.repos;
+    return expandWorkspace({ ...info, repos: seed });
+  }
+  const found = workspaceAt(info.root);
+  if (!found) return { ...info, repos: [] };
+  return expandWorkspace(found);
+};
+
+const worktreesOf = (top) => ({
+  root: top,
+  repos: [{ name: path.basename(top), dir: top }],
+  derived: true,
+});
+
+// What the watcher of the folder needs of a worktree besides the folder:
+// its git directory and, outside of the folder, its files
+const watchedBy = (root, row) => {
+  const key = dirKey(row.dir);
+  const rel = path.relative(root, key);
+  const inside = rel && !rel.startsWith('..') && !path.isAbsolute(rel);
+  const paths = inside ? [] : [key];
+  const dirs = resolveGitDirs(key);
+  if (dirs) paths.push(dirKey(dirs.gitDir));
+  return paths;
+};
+
+// A new worktree is a sibling of the main one: `app` and `app-feature`
+const worktreeTarget = (main, branch) => {
+  const slug = `${branch}`.trim().replace(UNSAFE_NAME, '-');
+  const base = path.basename(main.dir);
+  return path.join(path.dirname(main.dir), `${base}-${slug}`);
+};
+
+module.exports = {
+  expandWorkspace,
+  readWorkspace,
+  worktreesOf,
+  watchedBy,
+  worktreeTarget,
+};

package/lib/git/dir.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const GITDIR_PREFIX = 'gitdir:';
+
+const statOf = (file) => {
+  try {
+    return fs.statSync(file);
+  } catch {
+    return null;
+  }
+};
+
+const readFirstLine = (file) => {
+  try {
+    return fs.readFileSync(file, 'utf8').split('\n')[0] ?? '';
+  } catch {
+    return '';
+  }
+};
+
+// A linked worktree keeps `.git` as a file that points into the main one
+const gitDirOf = (dot) => {
+  const line = readFirstLine(dot).trim();
+  if (!line.startsWith(GITDIR_PREFIX)) return '';
+  const raw = line.slice(GITDIR_PREFIX.length).trim();
+  if (!raw) return '';
+  return path.resolve(path.dirname(dot), raw);
+};
+
+const commonGitDir = (gitDir) => {
+  const raw = readFirstLine(path.join(gitDir, 'commondir')).trim();
+  if (!raw) return gitDir;
+  return path.resolve(gitDir, raw);
+};
+
+// The directory with HEAD and the index, and the one with refs and objects
+const resolveGitDirs = (root) => {
+  const dot = path.join(path.resolve(root), '.git');
+  const stat = statOf(dot);
+  if (!stat) return null;
+  if (stat.isDirectory()) return { gitDir: dot, commonDir: dot, linked: false };
+  const gitDir = stat.isFile() ? gitDirOf(dot) : '';
+  if (!gitDir) return null;
+  return { gitDir, commonDir: commonGitDir(gitDir), linked: true };
+};
+
+module.exports = { resolveGitDirs };