atris 3.37.0 → 3.38.0

package/commands/skill.js

@@ -52,6 +52,11 @@ function getFrontmatterRaw(content) {
   return match ? match[1] : null;
 }
 
+// Pluralize a count + noun ("1 error", "2 errors").
+function countLabel(n, word) {
+  return `${n} ${word}${n === 1 ? '' : 's'}`;
+}
+
 // --- Skill Discovery ---
 
 function findAllSkills(skillsDir) {
@@ -504,7 +509,7 @@ function skillAudit(name) {
     }
 
     console.log('');
-    console.log(`  Score: ${passing}/${checks.length} (${errors} errors, ${warns} warnings)`);
+    console.log(`  Score: ${passing}/${checks.length} (${countLabel(errors, 'error')}, ${countLabel(warns, 'warning')})`);
 
     if (errors > 0 || warns > 0) {
       console.log(`  Run: atris skill fix ${skill.folder}`);
@@ -972,4 +977,4 @@ function skillCommand(subcommand, ...args) {
   }
 }
 
-module.exports = { skillCommand, parseFrontmatter, runAuditChecks, findAllSkills };
+module.exports = { skillCommand, parseFrontmatter, runAuditChecks, findAllSkills, countLabel };

package/commands/slop.js

@@ -9,7 +9,7 @@
 // Zero external deps (Node built-ins only) — repo contract.
 //
 // Usage:
-//   atris slop detect [path]        # scan a file or dir (default: .)
+//   atris slop detect [path...]      # scan one or more files or dirs (default: .)
 //   atris slop detect src/ --json   # machine output for CI / the loop
 //   atris slop detect src/ --quiet  # only print the summary line
 //
@@ -65,6 +65,9 @@ const RULES = [
   { id: 'decorative-blur-blob', sev: 'warn',
     re: /\bblur-3xl\b|filter:\s*blur\(\s*(?:6[4-9]|[7-9]\d|\d{3,})px\)/i,
     why: 'giant blurred gradient orb behind the hero (blur-3xl / 64px+ blur): the AI aurora-blob background reflex' },
+  { id: 'noise-grain-overlay', sev: 'warn',
+    re: /\bfeTurbulence\b|\bfractalNoise\b/i,
+    why: 'svg turbulence-noise used as a decorative grain/film texture overlay: the generated-look grain reflex' },
   { id: 'dark-hero-gradient', sev: 'warn',
     re: /\b(?:from|via)-(?:slate|gray|zinc|neutral|stone)-9(?:00|50)\b[^"'`]{0,80}\bto-(?:black|(?:slate|gray|zinc|neutral|stone)-950)\b/i,
     why: 'near-black slate/gray hero gradient fading to black: the dark premium SaaS template look' },
@@ -249,8 +252,15 @@ function detect(argv) {
     changed = gitChangedLines(staged);
     files = [...changed.keys()].filter((f) => SCAN_EXTS.has(path.extname(f)) && fs.existsSync(f));
   } else {
-    const target = argv.find((a) => !a.startsWith('-')) || '.';
-    files = walk(path.resolve(target), []);
+    let targets = argv.filter((a) => !a.startsWith('-'));
+    if (!targets.length) targets = ['.'];
+    const seen = new Set();
+    files = [];
+    for (const target of targets) {
+      for (const f of walk(path.resolve(target), [])) {
+        if (!seen.has(f)) { seen.add(f); files.push(f); }
+      }
+    }
   }
 
   let fixed = null;
@@ -297,8 +307,215 @@ function detect(argv) {
   return findings.length ? 1 : 0;
 }
 
+// --- dead-code detector: `atris slop dead` ------------------------------------
+// Dead code is slop too. Deterministic require-graph reachability: BFS from the
+// package entrypoints (package.json bin/scripts, bin/, scripts/) over static
+// require()/import edges. A JS file nothing reaches AND nothing names is dead.
+// Safety net for dynamic dispatch: any file whose basename appears as a string
+// literal anywhere in the repo is treated as referenced (protects --legacy
+// loops, docs-driven loading, and require(path.join(...)) patterns).
+
+const REQUIRE_RE = /require\(\s*['"]([^'"]+)['"]\s*\)|(?:^|\n)\s*(?:import|export)\s[^'"\n]*['"]([^'"]+)['"]|import\(\s*['"]([^'"]+)['"]\s*\)/g;
+
+function listJsFiles(dir, out = []) {
+  let names; try { names = fs.readdirSync(dir); } catch { return out; }
+  for (const name of names) {
+    if (name.startsWith('.') || SKIP_DIRS.has(name)) continue;
+    const p = path.join(dir, name);
+    let st; try { st = fs.statSync(p); } catch { continue; }
+    if (st.isDirectory()) listJsFiles(p, out);
+    else if (/\.(js|mjs|cjs)$/.test(name)) out.push(p);
+    else if (!name.includes('.') && st.isFile() && isNodeScript(p)) out.push(p); // extensionless node scripts (bin entries, `ax`) consume exports too
+  }
+  return out;
+}
+
+function isNodeScript(file) {
+  try {
+    const fd = fs.openSync(file, 'r');
+    const buf = Buffer.alloc(80);
+    const n = fs.readSync(fd, buf, 0, 80, 0);
+    fs.closeSync(fd);
+    const head = buf.toString('utf8', 0, n);
+    return head.startsWith('#!') && head.includes('node');
+  } catch { return false; }
+}
+
+// Resolve a relative specifier from `fromFile` to an absolute file path, or null.
+function resolveSpec(spec, fromFile) {
+  if (!spec || !spec.startsWith('.')) return null; // bare specifiers = node builtins/deps
+  const base = path.resolve(path.dirname(fromFile), spec);
+  for (const cand of [base, `${base}.js`, `${base}.mjs`, `${base}.cjs`, path.join(base, 'index.js')]) {
+    try { if (fs.statSync(cand).isFile()) return cand; } catch {}
+  }
+  return null;
+}
+
+function requireEdges(file) {
+  let text; try { text = fs.readFileSync(file, 'utf8'); } catch { return []; }
+  const edges = [];
+  let m;
+  REQUIRE_RE.lastIndex = 0;
+  while ((m = REQUIRE_RE.exec(text))) {
+    const resolved = resolveSpec(m[1] || m[2] || m[3], file);
+    if (resolved) edges.push(resolved);
+  }
+  return edges;
+}
+
+// Entrypoints: package.json bin values, node-invoking scripts, bin/, scripts/.
+function deadEntrypoints(root) {
+  const entries = new Set();
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+    const bins = typeof pkg.bin === 'string' ? [pkg.bin] : Object.values(pkg.bin || {});
+    for (const b of bins) { const p = path.resolve(root, b); if (fs.existsSync(p)) entries.add(p); }
+    for (const cmd of Object.values(pkg.scripts || {})) {
+      for (const ref of String(cmd).match(/[\w./-]+\.(?:js|mjs|cjs)\b/g) || []) {
+        const p = path.resolve(root, ref); if (fs.existsSync(p)) entries.add(p);
+      }
+    }
+  } catch {}
+  for (const dir of ['bin', 'scripts']) listJsFiles(path.join(root, dir)).forEach((f) => entries.add(f));
+  return entries;
+}
+
+function findDeadCode(root = process.cwd(), opts = {}) {
+  root = path.resolve(root);
+  const scanDirs = (opts.dirs || ['commands', 'lib']).map((d) => path.join(root, d));
+  const candidates = scanDirs.flatMap((d) => listJsFiles(d));
+  if (!candidates.length) return { root, candidates: 0, dead: [], testOnly: [] };
+
+  // 1) reachability BFS from entrypoints over static edges
+  const reached = new Set();
+  const queue = [...deadEntrypoints(root)];
+  while (queue.length) {
+    const f = queue.pop();
+    if (reached.has(f)) continue;
+    reached.add(f);
+    queue.push(...requireEdges(f));
+  }
+
+  // 2) test reachability (a file only tests import = suspicious, not proven dead)
+  const testReached = new Set();
+  const tq = listJsFiles(path.join(root, 'test'));
+  while (tq.length) {
+    const f = tq.pop();
+    if (testReached.has(f)) continue;
+    testReached.add(f);
+    tq.push(...requireEdges(f));
+  }
+
+  // 3) string-mention safety net: basename (sans ext) named as a string literal
+  //    outside itself. Split by scope: a mention in a NON-test file (prod code, a
+  //    bin entry like `ax`) means the file is dynamically dispatched — e.g.
+  //    require(path.join(__dirname, 'lib', 'permission-grants.js')) — and is
+  //    genuinely reachable even though the static edge parser and the test BFS
+  //    can't see the edge. That must outrank the test-only classification, or a
+  //    live feature imported by both `ax` and a test reads as "feature gone".
+  const testDir = path.join(root, 'test');
+  const isTestFile = (f) => f === testDir || f.startsWith(testDir + path.sep);
+  const allRepoJs = [...new Set([...listJsFiles(root)])];
+  const mentionedBy = (file, predicate) => {
+    const stem = path.basename(file).replace(/\.(js|mjs|cjs)$/, '');
+    const re = new RegExp(`['"\`/]${stem.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?:\\.js)?['"\`]`);
+    return allRepoJs.some((f) => {
+      if (f === file || !predicate(f)) return false;
+      try { return re.test(fs.readFileSync(f, 'utf8')); } catch { return false; }
+    });
+  };
+  const mentionedInProd = (file) => mentionedBy(file, (f) => !isTestFile(f));
+  const mentioned = (file) => mentionedBy(file, () => true);
+
+  const dead = [], testOnly = [];
+  for (const c of candidates) {
+    if (reached.has(c)) continue;
+    if (mentionedInProd(c)) continue; // dynamically dispatched from prod (e.g. the `ax` bin) — reachable
+    if (testReached.has(c)) { testOnly.push(c); continue; }
+    if (mentioned(c)) continue; // docs-driven / other dynamic dispatch — not provably dead
+    dead.push(c);
+  }
+  return { root, candidates: candidates.length, dead: dead.sort(), testOnly: testOnly.sort() };
+}
+
+// Orphaned exports: names a module exports that no other file ever mentions.
+// Word-boundary search across every other JS file keeps this high-precision:
+// a name used anywhere (import, dynamic access, test, doc string) never flags.
+function exportedNames(file) {
+  let text; try { text = fs.readFileSync(file, 'utf8'); } catch { return []; }
+  const names = new Set();
+  // module.exports = { a, b: c, ... }  — shorthand entries and keys
+  const block = text.match(/module\.exports\s*=\s*\{([\s\S]*?)\n\}/);
+  if (block) {
+    for (const line of block[1].split('\n')) {
+      const m = line.match(/^\s*([A-Za-z_$][\w$]*)\s*[,:]?\s*(?:\/\/.*)?$/) || line.match(/^\s*([A-Za-z_$][\w$]*)\s*:/);
+      if (m) names.add(m[1]);
+    }
+  }
+  // exports.foo = / module.exports.foo =
+  for (const m of text.matchAll(/(?:module\.)?exports\.([A-Za-z_$][\w$]*)\s*=/g)) names.add(m[1]);
+  return [...names];
+}
+
+function findOrphanedExports(root, files, allRepoJs) {
+  const texts = new Map();
+  const readText = (f) => {
+    if (!texts.has(f)) { try { texts.set(f, fs.readFileSync(f, 'utf8')); } catch { texts.set(f, ''); } }
+    return texts.get(f);
+  };
+  const orphans = [];
+  for (const file of files) {
+    for (const name of exportedNames(file)) {
+      if (name.length < 4) continue; // generic short names drown in noise either way
+      const re = new RegExp(`\\b${name}\\b`);
+      const used = allRepoJs.some((f) => f !== file && re.test(readText(f)));
+      if (!used) orphans.push({ file, name });
+    }
+  }
+  return orphans;
+}
+
+function deadCommand(argv) {
+  const json = argv.includes('--json');
+  const withExports = argv.includes('--exports');
+  const root = argv.find((a) => !a.startsWith('-')) || '.';
+  const res = findDeadCode(root);
+  const rel = (f) => path.relative(res.root, f);
+
+  let orphans = null;
+  if (withExports && res.candidates) {
+    const scanDirs = ['commands', 'lib'].map((d) => path.join(res.root, d));
+    const files = scanDirs.flatMap((d) => listJsFiles(d));
+    orphans = findOrphanedExports(res.root, files, listJsFiles(res.root));
+  }
+
+  const bad = res.dead.length + (orphans ? orphans.length : 0);
+  if (json) {
+    console.log(JSON.stringify({
+      ok: bad === 0, candidates: res.candidates,
+      dead: res.dead.map(rel), test_only: res.testOnly.map(rel),
+      ...(orphans ? { orphaned_exports: orphans.map((o) => ({ file: rel(o.file), name: o.name })) } : {}),
+    }, null, 2));
+    return bad ? 1 : 0;
+  }
+  if (!bad && !res.testOnly.length) {
+    console.log(`\n  ✓ no dead code — all ${res.candidates} files reachable from the entrypoints\n`);
+    return 0;
+  }
+  console.log('');
+  for (const f of res.dead) console.log(`  ✗ ${rel(f).padEnd(40)} unreachable and unreferenced — delete it`);
+  for (const f of res.testOnly) console.log(`  ⚠ ${rel(f).padEnd(40)} only tests import it — feature gone, test lingers?`);
+  if (orphans) for (const o of orphans) console.log(`  ⚠ ${`${rel(o.file)} → ${o.name}`.padEnd(40)} exported but nothing anywhere names it — drop the export entry`);
+  const parts = [`${res.dead.length} dead`, `${res.testOnly.length} test-only`];
+  if (orphans) parts.push(`${orphans.length} orphaned export${orphans.length === 1 ? '' : 's'}`);
+  console.log(`\n  ${parts.join(', ')} of ${res.candidates} files · exit ${bad ? 1 : 0}\n`);
+  return bad ? 1 : 0;
+}
+
 function slopCommand(argv) {
-  const sub = argv[0];
+  let sub = argv[0];
+  if (sub === 'dead') return deadCommand(argv.slice(1));
+  if (sub === '-h' || sub === '--help') sub = 'help';
   if (!sub || sub === 'detect' || sub.startsWith('-') || !['detect', 'rules', 'help', 'hook', 'install-hook'].includes(sub)) {
     // default + `detect`: scan. Bare `atris slop` scans cwd too.
     const rest = sub === 'detect' ? argv.slice(1) : argv;
@@ -337,14 +554,15 @@ function slopCommand(argv) {
   console.log(`
   atris slop — deterministic slop detector + repairer (no LLM)
 
-    atris slop detect [path]      scan a file or dir (default: .)
+    atris slop detect [path...]   scan one or more files or dirs (default: .)
     atris slop detect --diff      scan only changed lines (commit/PR gate)
     atris slop detect --staged    scan only staged changes (pre-commit hook)
     atris slop detect --fix       auto-repair the safe tells (em dashes), report the rest
-    atris slop detect [path] --json   machine output for CI / the loop
+    atris slop detect [path...] --json   machine output for CI / the loop
     atris slop rules              list active rules (built-in + project)
     atris slop rules --add <id> <pattern> <why>   grow the project ruleset
     atris slop hook               install a pre-commit gate (runs --staged)
+    atris slop dead [root]        find dead JS (unreachable + unreferenced files)
 
   Project rules live in .atris/slop.rules.json and compound over time.
   exit 0 = clean, 1 = slop found. Wire into PR checks and the autopilot gate.
@@ -352,4 +570,4 @@ function slopCommand(argv) {
   return 0;
 }
 
-module.exports = { slopCommand, detect, scanFile, RULES, PAIR_RULES, loadProjectRules, addProjectRule, gitChangedLines, applyFixes, installHook };
+module.exports = { slopCommand, detect, scanFile, RULES, PAIR_RULES, loadProjectRules, addProjectRule, gitChangedLines, applyFixes, installHook, findDeadCode, findOrphanedExports, listJsFiles };

package/commands/status.js

@@ -3,6 +3,7 @@ const path = require('path');
 const { getLogPath, ensureLogDirectory, createLogFile } = require('../lib/journal');
 const { parseTodo, getTeamActivity } = require('../lib/todo');
 const { clarify } = require('../lib/autoland');
+const { checkoutBehindMessage } = require('../lib/checkout-sync');
 
 // Box drawing helpers
 const W = 64; // inner width
@@ -200,6 +201,7 @@ function statusAtris(isQuick = false, jsonMode = false, verbose = false) {
 
   // Get team activity
   const teamActivity = getTeamActivity(targetDir);
+  const checkoutWarning = checkoutBehindMessage(process.cwd());
 
   // JSON mode — structured output for scripting
   if (jsonMode) {
@@ -217,6 +219,10 @@ function statusAtris(isQuick = false, jsonMode = false, verbose = false) {
     return;
   }
 
+  if (checkoutWarning) {
+    console.log(checkoutWarning);
+  }
+
   // Quick mode
   if (isQuick) {
     console.log(`📋 ${todo.backlog.length} | 🔨 ${todo.inProgress.length} | ✅ ${todo.completed.length} | 📥 ${inboxItems.length} | 📚 ${lessonsCount}`);

package/commands/stream.js

@@ -855,7 +855,5 @@ module.exports = {
   renderRecords,
   renderTextLine,
   repoRoot,
-  sanitizeSummary,
-  snapshotRecords,
   streamCommand,
 };

package/commands/study.js

@@ -685,9 +685,6 @@ async function run(argv = []) {
 module.exports = {
   run,
   parseArgs,
-  detectLanguage,
   showHelp,
-  BACKEND_ROOT,
   wrapText,
-  createWhileChild,
 };

package/commands/sync-checkout.js

@@ -0,0 +1,51 @@
+'use strict';
+
+const {
+  runGit,
+  trackedTreeIsClean,
+} = require('../lib/checkout-sync');
+
+function refuse(message) {
+  console.log(message);
+  return 1;
+}
+
+function syncCheckoutCommand(args = [], cwd = process.cwd()) {
+  if (args.includes('--help') || args.includes('-h') || args[0] === 'help') {
+    console.log('usage: atris sync-checkout.');
+    return 0;
+  }
+
+  const branchResult = runGit(['symbolic-ref', '--quiet', '--short', 'HEAD'], cwd);
+  if (branchResult.status !== 0) {
+    return refuse('this checkout is not on a git branch; sync-checkout refused to touch it.');
+  }
+
+  if (!trackedTreeIsClean(cwd)) {
+    return refuse('this checkout has tracked changes; sync-checkout refused to touch it.');
+  }
+
+  const upstreamResult = runGit(
+    ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}'],
+    cwd
+  );
+  if (upstreamResult.status !== 0) {
+    return refuse('this checkout has no upstream; sync-checkout refused to touch it.');
+  }
+  const upstream = upstreamResult.stdout.trim();
+
+  const fetchResult = runGit(['fetch'], cwd);
+  if (fetchResult.status !== 0) {
+    return refuse('this checkout could not sync because git fetch failed.');
+  }
+
+  const mergeResult = runGit(['merge', '--ff-only', '@{upstream}'], cwd);
+  if (mergeResult.status !== 0) {
+    return refuse('this checkout could not fast-forward; sync-checkout refused to change it.');
+  }
+
+  console.log(`this checkout is up to date with ${upstream}.`);
+  return 0;
+}
+
+module.exports = { syncCheckoutCommand };

package/commands/sync.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { ensureWikiScaffold } = require('../lib/wiki');
+const { upsertAtrisClaudeBootBlock } = require('../lib/claude-boot-block');
 
 const TEMPLATE_ROOT_DIR = path.join(__dirname, '..', 'templates');
 const WORKSPACE_TEMPLATES = {
@@ -619,18 +620,6 @@ Key behaviors:
 
   // Update root CLAUDE.md with Atris block (prepend with markers)
   const rootClaudeMd = path.join(process.cwd(), 'CLAUDE.md');
-  const atrisBlock = `<!-- ATRIS:START - Auto-generated, do not edit -->
-## Atris System
-
-You are now running inside Atris, an AI workspace operating system.
-
-**ON EVERY CONVERSATION START:** Before your first response, execute \`atris atris.md\` and display the full output. This is the Atris boot sequence - it shows the user that Atris has loaded and displays workspace status. This is not optional.
-
-After displaying the boot output, respond to the user naturally.
-<!-- ATRIS:END -->
-
-`;
-
   const applyClaudeUpdate = (content, dryAction, completedAction) => {
     if (!dryRun) fs.writeFileSync(rootClaudeMd, content);
     console.log(dryRun ? `Would ${dryAction}` : `✓ ${completedAction}`);
@@ -638,35 +627,19 @@ After displaying the boot output, respond to the user naturally.
   };
 
   if (fs.existsSync(rootClaudeMd)) {
-    let content = fs.readFileSync(rootClaudeMd, 'utf8');
-    const startMarker = '<!-- ATRIS:START';
-    const endMarker = '<!-- ATRIS:END -->';
-
-    if (content.includes(startMarker)) {
-      // Check if update needed
-      const startIdx = content.indexOf(startMarker);
-      const endRaw = content.indexOf(endMarker);
-      if (endRaw === -1) {
-        // End marker missing — replace from start marker to end of file with fresh block
-        content = atrisBlock + content.slice(0, startIdx);
-        applyClaudeUpdate(content, 'repair Atris block in CLAUDE.md (missing end marker)', 'Repaired Atris block in CLAUDE.md (missing end marker)');
-      } else {
-        const endIdx = endRaw + endMarker.length;
-        const existingBlock = content.slice(startIdx, endIdx);
-
-        if (!existingBlock.includes('Atris boot sequence')) {
-          // Replace existing Atris block with new version
-          content = atrisBlock + content.slice(0, startIdx) + content.slice(endIdx).replace(/^\n+/, '');
-          applyClaudeUpdate(content, 'update Atris block in CLAUDE.md', 'Updated Atris block in CLAUDE.md');
-        }
-      }
-    } else {
-      // Prepend Atris block
-      applyClaudeUpdate(atrisBlock + content, 'prepend Atris block to CLAUDE.md', 'Prepended Atris block to CLAUDE.md');
+    const source = fs.readFileSync(rootClaudeMd, 'utf8');
+    const result = upsertAtrisClaudeBootBlock(source);
+    if (result.action === 'repaired') {
+      applyClaudeUpdate(result.content, 'repair atris block in CLAUDE.md (missing end marker)', 'repaired atris block in CLAUDE.md (missing end marker)');
+    } else if (result.action === 'updated') {
+      applyClaudeUpdate(result.content, 'update atris block in CLAUDE.md', 'updated atris block in CLAUDE.md');
+    } else if (result.action === 'prepended') {
+      applyClaudeUpdate(result.content, 'prepend atris block to CLAUDE.md', 'prepended atris block to CLAUDE.md');
     }
   } else {
     // Create new CLAUDE.md with just Atris block
-    applyClaudeUpdate(atrisBlock.trim() + '\n', 'create CLAUDE.md with Atris block', 'Created CLAUDE.md with Atris block');
+    const content = upsertAtrisClaudeBootBlock().content;
+    applyClaudeUpdate(content, 'create CLAUDE.md with atris block', 'created CLAUDE.md with atris block');
   }
 
   if (dryRun) {
@@ -990,8 +963,6 @@ module.exports = {
   syncSkills,
   syncBusinessCanonical,
   syncWorkspaceTemplate,
-  resolveWorkspaceTemplate,
   ensureWorkspaceStateFiles,
-  renderBusinessAgentAdapter,
   ensureBusinessRootAgentAdapters,
 };