atris 3.72.4 → 3.73.0

package/lib/zen-apply.js

@@ -15,6 +15,7 @@ const {
   checkZen,
   defaultBranch,
   dirtyEntries,
+  dirtyFiles,
   FRESH_MINUTES,
   gitOut,
   headMovedSince,
@@ -188,8 +189,9 @@ function saveStrayEdits(root, teamState, tag, cutoff) {
   for (const entry of dirtyEntries(root)) {
     if (isTeamState(entry.path, teamState)) continue;
     const paths = entry.xy === '??' && entry.path.endsWith('/')
-      ? untrackedFiles(root, entry.path)
+      ? untrackedFiles(root, entry.path).filter((p) => !isTeamState(p, teamState))
       : [entry.path, entry.orig].filter(Boolean);
+    if (!paths.length) continue;
     const isFresh = paths.some((p) => mtime(path.join(root, p)) > cutoff);
     for (const p of paths) (isFresh ? fresh : files).add(p);
   }
@@ -365,7 +367,15 @@ function moveKeepingNotes(root, args, target, tag, from = 'HEAD') {
     .flatMap((e) => (e.path.endsWith('/') ? untrackedFiles(root, e.path) : [e.path]))
     .filter((p) => changed.has(p))
     .concat(added);
-  if (!tracked.length && !untracked.length) return { ok: false, error: firstLine(first.stderr) };
+  // A note you moved with git mv whose old path changed upstream: the old
+  // path goes back to HEAD so the move can run, and the new edits are merged
+  // into your moved copy afterwards.
+  const renamed = dirty.filter((e) => e.xy[0] === 'R' && e.orig && changed.has(e.orig) && !changed.has(e.path));
+  for (const e of renamed) {
+    runGit(['reset', '-q', '--', e.orig, e.path], root);
+    runGit(['checkout', '-q', 'HEAD', '--', e.orig], root);
+  }
+  if (!tracked.length && !untracked.length && !renamed.length) return { ok: false, error: firstLine(first.stderr) };
 
   const dir = path.join(commonDir(root), 'atris-zen', tag);
   fs.mkdirSync(dir, { recursive: true });
@@ -423,6 +433,16 @@ function moveKeepingNotes(root, args, target, tag, from = 'HEAD') {
       fs.copyFileSync(saved, path.join(root, p));
     }
   }
+  for (const e of renamed) {
+    const old = path.join(root, e.orig);
+    if (second.status !== 0 || !fs.existsSync(old)) continue;
+    if (fromCommit && followMove(root, fromCommit, e.orig, e.path, old)) {
+      fs.rmSync(old, { force: true });
+      notes.push(`${e.orig} changed upstream after you moved it to ${e.path}; the new edits went with it`);
+    } else {
+      notes.push(`${e.orig} changed upstream after you moved it to ${e.path}; the new version is back at ${e.orig}`);
+    }
+  }
   if (second.status !== 0) return { ok: false, error: firstLine(second.stderr), notes, tracked, landed };
   return { ok: true, notes, tracked, landed };
 }
@@ -522,7 +542,7 @@ function applyZen({ cwd = process.cwd(), fetch = true, freshMinutes, abandonedDa
 
   let branch = gitOut(['symbolic-ref', '--quiet', '--short', 'HEAD'], root);
   if (main && branch !== main) {
-    const stillStray = dirtyEntries(root).some((e) => !isTeamState(e.path, teamState));
+    const stillStray = dirtyFiles(root).some((p) => !isTeamState(p, teamState));
     if (stillStray || homeInUse) {
       left.push(`stayed on ${branch || 'a detached commit'}, because it was used in ${window}`);
     } else {
@@ -536,8 +556,12 @@ function applyZen({ cwd = process.cwd(), fetch = true, freshMinutes, abandonedDa
       const base = gitOut(['merge-base', 'HEAD', main], root);
       const moved = moveKeepingNotes(root, ['checkout', '-q', main], main, tag, base || 'HEAD');
       notes.push(...(moved.notes || []));
+      // A branch with nothing beyond origin is cleared as finished below, so
+      // only a branch with its own commits is called kept.
+      const own = branch && before.upstream ? gitOut(['rev-list', '--count', `${before.upstream}..${branch}`], root) : null;
       if (moved.ok) {
-        done.push(`moved back to ${main}${branch ? ` (${branch} is kept)` : ''}`);
+        const why = !branch ? '' : own === '0' ? ` (${branch} had nothing new)` : ` (${branch} is kept)`;
+        done.push(`moved back to ${main}${why}`);
         branch = main;
       } else {
         left.push(`could not move to ${main}: ${moved.error}`);

package/lib/zen-fleet.js

@@ -0,0 +1,100 @@
+'use strict';
+
+// Zen for every repo you keep, in one run. The list comes from the command
+// line or ~/.atris/zen.json ({"repos": ["~/code/app", ...]}). A repo whose
+// unsaved edits touch live app data or secrets is skipped whole, because a
+// person should look at it first. Each repo gets one line, then one shared
+// list of what only a person can do.
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { DEFAULT_TEAM_STATE, dirtyEntries, untrackedFiles } = require('./zen');
+const { applyZen } = require('./zen-apply');
+
+const LIVE_DATA = DEFAULT_TEAM_STATE.filter((p) => p.startsWith('*.')).map((p) => p.slice(1));
+const SECRET = /(^|\/)(\.env(\..+)?|id_rsa[^/]*|[^/]*\.(pem|key|p12)|[^/]*(secret|credential)[^/]*)$/i;
+
+function fleetFile() {
+  return process.env.ATRIS_ZEN_FLEET_FILE || path.join(os.homedir(), '.atris', 'zen.json');
+}
+
+function expand(p) {
+  return path.resolve(p.replace(/^~(?=$|\/)/, os.homedir()));
+}
+
+function fleetRepos(paths = []) {
+  if (paths.length) return paths.map(expand);
+  try {
+    const listed = JSON.parse(fs.readFileSync(fleetFile(), 'utf8')).repos;
+    return Array.isArray(listed) ? listed.filter((p) => typeof p === 'string').map(expand) : [];
+  } catch {
+    return [];
+  }
+}
+
+// Unsaved edits that look like live app data or secrets.
+function riskyEdits(root) {
+  return dirtyEntries(root)
+    .flatMap((e) => (e.xy === '??' && e.path.endsWith('/') ? untrackedFiles(root, e.path) : [e.path]))
+    .filter((p) => LIVE_DATA.some((ext) => p.endsWith(ext)) || SECRET.test(p));
+}
+
+function home(p) {
+  const dir = os.homedir();
+  return p === dir || p.startsWith(dir + path.sep) ? `~${p.slice(dir.length)}` : p;
+}
+
+function zenOne(repo, fetch) {
+  const name = path.basename(repo);
+  if (!fs.existsSync(repo)) return { repo, name, state: 'missing', text: `not found at ${home(repo)}`, yours: [] };
+  const risky = riskyEdits(repo);
+  if (risky.length) {
+    const shown = risky.slice(0, 3).join(', ') + (risky.length > 3 ? ` and ${risky.length - 3} more` : '');
+    return { repo, name, state: 'skipped', text: `skipped, unsaved live data or secrets: ${shown}`, yours: [] };
+  }
+  let result;
+  try {
+    result = applyZen({ cwd: repo, fetch });
+  } catch (err) {
+    return { repo, name, state: 'failed', text: `zen stopped: ${String(err.message || err).split('\n')[0]}`, yours: [] };
+  }
+  if (!result.ok) return { repo, name, state: 'failed', text: `can't start, ${result.error}`, yours: [] };
+  const did = [...result.done, ...(result.workspace?.done || [])];
+  let text = result.already ? 'already zen' : did.join(', ') || 'zen';
+  if (!result.zen) text += `; still out of place: ${result.remaining.join(', ')}`;
+  // Where your copy went and what was left alone matter as much as what was
+  // done, so they ride along under the repo line. Side copy paths stay out to
+  // keep the pane small; plain atris zen in that repo lists them.
+  const more = [...result.notes, ...result.left.filter((line) => !/^\s/.test(line))];
+  return { repo, name, state: result.zen ? 'zen' : 'almost', text, more, yours: result.workspace?.yours || [] };
+}
+
+function fleetZen({ repos, fetch = true } = {}) {
+  return repos.map((repo) => zenOne(repo, fetch));
+}
+
+function printFleet(results) {
+  const width = Math.max(...results.map((r) => r.name.length));
+  console.log('');
+  console.log('  atris zen, every repo');
+  console.log('');
+  for (const r of results) {
+    console.log(`  ${r.name.padEnd(width)}  ${r.text}`);
+    for (const line of r.more || []) console.log(`  ${''.padEnd(width)}  ${line}`);
+  }
+  const yours = results.flatMap((r) => r.yours.map((item) => ({ text: `${r.name}: ${item.text}`, cmd: item.cmd })));
+  if (yours.length) {
+    console.log('');
+    console.log('  for you');
+    const w = Math.max(...yours.map((item) => item.text.length));
+    for (const item of yours) console.log(`  ${item.text.padEnd(w)}   ${item.cmd}`);
+  }
+  const calm = results.filter((r) => r.state === 'zen').length;
+  const skipped = results.filter((r) => r.state === 'skipped').length;
+  console.log('');
+  console.log(`  ${calm} of ${results.length} repos zen${skipped ? `, ${skipped} skipped for you to look at` : ''}.`);
+  console.log('');
+}
+
+module.exports = { fleetFile, fleetRepos, fleetZen, printFleet, riskyEdits };

package/lib/zen.js

@@ -91,6 +91,14 @@ function dirtyPaths(root) {
   return dirtyEntries(root).map((entry) => entry.path);
 }
 
+// Changed files with untracked folders opened up, so a live database inside
+// a new folder is seen as live data, not as part of a stray folder.
+function dirtyFiles(root) {
+  return dirtyEntries(root).flatMap((entry) => (entry.xy === '??' && entry.path.endsWith('/')
+    ? untrackedFiles(root, entry.path)
+    : [entry.path]));
+}
+
 function listWorktrees(root) {
   const out = gitOut(['worktree', 'list', '--porcelain'], root) || '';
   const worktrees = [];
@@ -111,14 +119,41 @@ function listWorktrees(root) {
   return worktrees;
 }
 
+function expandHome(text) {
+  const home = os.homedir();
+  return text.replace(/\$\{?HOME\}?/g, home).replace(/(^|[\s"'=:])~\//g, `$1${home}/`);
+}
+
+// A job often runs a script that names the side copy, not the copy itself,
+// so the scripts a schedule runs are read too, one level down. Logs are left
+// out, and so is anything large or binary.
+function withScripts(text) {
+  const seen = new Set();
+  const parts = [text];
+  for (const [file] of expandHome(text).matchAll(/\/[^\s"'<>;|&()]+/g)) {
+    if (seen.has(file) || file.endsWith('.log')) continue;
+    seen.add(file);
+    try {
+      const stat = fs.statSync(file);
+      if (!stat.isFile() || stat.size > 256 * 1024) continue;
+      const body = fs.readFileSync(file, 'utf8');
+      if (!body.includes('\0')) parts.push(body);
+    } catch {
+      // Not a readable file.
+    }
+  }
+  return parts.join('\n');
+}
+
 // Text of the jobs this machine runs on a schedule: the user crontab and
-// launchd agents. A side copy named there is in use even when it looks idle.
+// launchd agents, plus the scripts they run. A side copy named there is in
+// use even when it looks idle.
 // ATRIS_ZEN_SCHEDULE_FILE points at a file to read instead (tests).
 function scheduleText() {
   const override = process.env.ATRIS_ZEN_SCHEDULE_FILE;
   if (override) {
     try {
-      return fs.readFileSync(override, 'utf8');
+      return withScripts(fs.readFileSync(override, 'utf8'));
     } catch {
       return '';
     }
@@ -134,13 +169,12 @@ function scheduleText() {
   } catch {
     // No launchd agents.
   }
-  return parts.join('\n');
+  return withScripts(parts.join('\n'));
 }
 
 function scheduledCopies(worktrees, text = scheduleText()) {
   if (!text) return new Set();
-  const home = os.homedir();
-  const expanded = text.replace(/\$\{?HOME\}?/g, home).replace(/(^|[\s"'=:])~\//g, `$1${home}/`);
+  const expanded = expandHome(text);
   const used = new Set();
   for (const wt of worktrees) {
     const at = path.resolve(wt.path);
@@ -279,7 +313,7 @@ function checkZen({ cwd = process.cwd(), fetch = true, freshMinutes = freshMinut
   }
 
   const teamState = readTeamState(root);
-  const dirty = dirtyPaths(root);
+  const dirty = dirtyFiles(root);
   const stray = dirty.filter((file) => !isTeamState(file, teamState));
   const teamFiles = dirty.length - stray.length;
   if (stray.length) {
@@ -403,6 +437,7 @@ module.exports = {
   dirtyEntries,
   gitOut,
   isTeamState,
+  dirtyFiles,
   listWorktrees,
   readTeamState,
   scheduledCopies,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.72.4",
+  "version": "3.73.0",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "main": "bin/atris.js",
   "bin": {

package/scripts/det/xsearch-bench.js

@@ -303,5 +303,6 @@ module.exports = {
   fixtureFetch,
   runOfflineCheck,
   saveFailedOutput,
+  startCountingServer,
   summary,
 };