atris 3.72.5 → 3.73.0

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.5",
+  "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": {