atris 3.69.0 → 3.70.0

package/lib/member-report.js

@@ -0,0 +1,314 @@
+'use strict';
+
+// `atris member report [--since <time>] [--json]`: a short per-member summary
+// of what the team did. Four groups, newest first, one line per piece of work:
+//   merged       diary "Task completed" with action merged, plus the PR link
+//   finished     diary mission ticks whose check passed, accepted tasks, completed missions
+//   turned down  tasks a person sent back (task db) and tasks set aside (diary), with the reason
+//   waiting      tasks sitting in review for a person right now (task db)
+// Diary headings are `## HH:MM · title` in local time and the file name holds
+// the date, so every time here is local; nothing prints in UTC.
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_SINCE = '24h';
+const PER_GROUP = 3;
+const LOG_NAME_RE = /^(\d{4})-(\d{2})-(\d{2})\.md$/;
+const HEADING_RE = /^##\s+(\d{1,2}):(\d{2})\s*(?:·|-|:)?\s*(.*)$/;
+const FIELD_RE = /^-\s+([a-z_][a-z0-9_ ]*):\s*(.*)$/i;
+const URL_RE = /https?:\/\/\S+/;
+const GROUPS = [
+  ['merged', 'merged'],
+  ['finished', 'finished'],
+  ['turned_down', 'turned down'],
+  ['waiting', 'not merged yet'],
+];
+
+function usage() {
+  return [
+    'usage:',
+    '  atris member report [--since <time>] [--json]',
+    '',
+    'a short summary of what each member got merged, finished, had turned down,',
+    'and what is done but not merged yet.',
+    '',
+    'options:',
+    '  --since <time>  2h, 30m, 3d, today, yesterday, a date, or an iso time (default: 24h)',
+    '  --json          print the report as json',
+  ].join('\n');
+}
+
+function localMidnight(date) {
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate());
+}
+
+// Returns a Date, or null when the text is not a time we understand.
+function parseSince(text, now = new Date()) {
+  const raw = String(text || '').trim().toLowerCase();
+  if (!raw) return null;
+  if (raw === 'today') return localMidnight(now);
+  if (raw === 'yesterday') {
+    const day = localMidnight(now);
+    day.setDate(day.getDate() - 1);
+    return day;
+  }
+  const relative = raw.match(/^(\d+)\s*(m|min|h|hr|d|day|days)$/);
+  if (relative) {
+    const unit = relative[2][0];
+    const ms = Number(relative[1]) * (unit === 'm' ? 60e3 : unit === 'h' ? 3600e3 : 86400e3);
+    return new Date(now.getTime() - ms);
+  }
+  const dateOnly = raw.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (dateOnly) return new Date(Number(dateOnly[1]), Number(dateOnly[2]) - 1, Number(dateOnly[3]));
+  const ms = Date.parse(String(text).trim());
+  return Number.isFinite(ms) ? new Date(ms) : null;
+}
+
+function parseReportArgs(args = []) {
+  let since = DEFAULT_SINCE;
+  let json = false;
+  let help = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = String(args[index]);
+    if (arg === '--help' || arg === '-h') { help = true; continue; }
+    if (arg === '--json') { json = true; continue; }
+    if (arg === '--since') {
+      if (index + 1 >= args.length) throw new Error('--since needs a time, like 2h or yesterday');
+      since = String(args[index + 1]);
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith('--since=')) { since = arg.slice('--since='.length); continue; }
+    throw new Error(`unknown option ${arg}\n${usage()}`);
+  }
+  return { help, since, json };
+}
+
+function parseDiary(text, year, month, day) {
+  const entries = [];
+  let current = null;
+  for (const line of String(text || '').split('\n')) {
+    const heading = line.match(HEADING_RE);
+    if (heading) {
+      const at = new Date(year, month - 1, day, Number(heading[1]), Number(heading[2]));
+      current = { at, title: heading[3].trim(), fields: {} };
+      entries.push(current);
+      continue;
+    }
+    const field = current && line.match(FIELD_RE);
+    if (field) {
+      const key = field[1].trim().toLowerCase();
+      if (!(key in current.fields)) current.fields[key] = field[2].trim();
+    }
+  }
+  return entries;
+}
+
+function memberNames(root) {
+  const teamDir = path.join(root, 'atris', 'team');
+  if (!fs.existsSync(teamDir)) return null;
+  return fs.readdirSync(teamDir, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && !/^[._]/.test(entry.name))
+    .map((entry) => entry.name)
+    .sort();
+}
+
+function diaryEntriesSince(root, member, since) {
+  const logsDir = path.join(root, 'atris', 'team', member, 'logs');
+  if (!fs.existsSync(logsDir)) return [];
+  const sinceDay = localMidnight(since).getTime();
+  const entries = [];
+  for (const name of fs.readdirSync(logsDir).sort()) {
+    const match = name.match(LOG_NAME_RE);
+    if (!match) continue;
+    const [year, month, day] = match.slice(1).map(Number);
+    if (new Date(year, month - 1, day).getTime() < sinceDay) continue;
+    const text = fs.readFileSync(path.join(logsDir, name), 'utf8');
+    for (const entry of parseDiary(text, year, month, day)) {
+      if (entry.at.getTime() >= since.getTime()) entries.push(entry);
+    }
+  }
+  return entries;
+}
+
+// One diary entry becomes at most one summary item, or null when it is
+// bookkeeping (claimed, started, notes, ticks that did not pass their check).
+function classifyDiaryEntry(entry) {
+  const f = entry.fields;
+  const kind = entry.title.replace(/\s+\d+$/, '');
+  if (kind === 'Task completed' && f.action === 'merged') {
+    const link = (String(f.proof || '').match(URL_RE) || [''])[0].replace(/[).,]+$/, '');
+    return { group: 'merged', title: f.title, link: link || null };
+  }
+  if (kind === 'Task completed' || kind === 'Task accepted') return { group: 'finished', title: f.title };
+  if (kind === 'Mission completed') return { group: 'finished', title: f.mission || f.title };
+  if (kind === 'Mission run tick' && f.verifier === 'passed') {
+    return { group: 'finished', title: f.mission, detail: f.summary };
+  }
+  if (kind === 'Task archived' || kind === 'Task failed') {
+    return { group: 'turned_down', title: f.title, reason: f.proof || f.reason || null };
+  }
+  return null;
+}
+
+// Rows from the task db for this workspace: who sent work back and what is
+// waiting on a person. Tasks with no team member behind them are skipped.
+function taskItems(tasks, sinceMs, members) {
+  const known = new Set(members);
+  const items = [];
+  for (const task of tasks || []) {
+    const meta = task && task.metadata && typeof task.metadata === 'object' ? task.metadata : {};
+    const member = [meta.built_by, meta.assigned_to, task.claimed_by].find((name) => name && known.has(name));
+    if (!member) continue;
+    if (task.status !== 'review') continue;
+    if (meta.approval_status === 'revise') {
+      const at = Date.parse(meta.human_revision_at || '');
+      if (Number.isFinite(at) && at >= sinceMs) {
+        items.push({ member, at, group: 'turned_down', title: task.title, reason: meta.human_revision_note || null });
+      }
+      continue;
+    }
+    items.push({ member, at: Number(task.updated_at) || 0, group: 'waiting', title: task.title });
+  }
+  return items;
+}
+
+function sameTitle(a, b) {
+  return String(a || '').trim().toLowerCase() === String(b || '').trim().toLowerCase();
+}
+
+function summarize(items) {
+  const groups = { merged: [], finished: [], turned_down: [], waiting: [] };
+  const sorted = [...items].sort((a, b) => b.at - a.at);
+  for (const item of sorted) {
+    if (!item.title) continue;
+    // Newest word on a piece of work wins, and merged beats finished.
+    if (Object.values(groups).some((list) => list.some((seen) => sameTitle(seen.title, item.title)))) continue;
+    const { member, at, group, ...rest } = item;
+    groups[group].push(rest);
+  }
+  return groups;
+}
+
+function memberReport(root, { since = DEFAULT_SINCE, now = new Date(), tasks = [] } = {}) {
+  const sinceAt = parseSince(since, now);
+  if (!sinceAt) throw new Error(`--since "${since}" is not a time; try 2h, yesterday, or 2026-10-14`);
+  const names = memberNames(root);
+  if (!names) throw new Error('no atris/team folder here; run this inside an atris workspace');
+  const fromTasks = taskItems(tasks, sinceAt.getTime(), names);
+  const members = names
+    .map((member) => {
+      const items = diaryEntriesSince(root, member, sinceAt)
+        .map((entry) => {
+          const item = classifyDiaryEntry(entry);
+          return item ? { member, at: entry.at.getTime(), ...item } : null;
+        })
+        .filter(Boolean)
+        .concat(fromTasks.filter((item) => item.member === member));
+      const groups = summarize(items);
+      const total = Object.values(groups).reduce((sum, list) => sum + list.length, 0);
+      return { member, total, ...groups };
+    })
+    .filter((row) => row.total > 0)
+    .sort((a, b) => b.total - a.total || a.member.localeCompare(b.member));
+  const totals = {};
+  for (const [key] of GROUPS) totals[key] = members.reduce((sum, row) => sum + row[key].length, 0);
+  return { ok: true, action: 'report', since: localStamp(sinceAt, now), totals, members };
+}
+
+function pad(n) {
+  return String(n).padStart(2, '0');
+}
+
+// "14:05" today, "yesterday 14:05", or "10-12 14:05"; always the local clock.
+function localStamp(at, now) {
+  const time = `${pad(at.getHours())}:${pad(at.getMinutes())}`;
+  const days = Math.round((localMidnight(now) - localMidnight(at)) / 86400e3);
+  if (days === 0) return time;
+  if (days === 1) return `yesterday ${time}`;
+  return `${pad(at.getMonth() + 1)}-${pad(at.getDate())} ${time}`;
+}
+
+function clip(text, max) {
+  const flat = String(text || '').replace(/\s+/g, ' ').trim();
+  return flat.length > max ? `${flat.slice(0, max - 3)}...` : flat;
+}
+
+// The first sentence of a tick summary says what changed in plain words; the
+// mission text is the job description, so it is only the fallback.
+function firstSentence(text) {
+  const flat = String(text || '').replace(/\s+/g, ' ').trim();
+  const match = flat.match(/^.*?[.!?](?=\s|$)/);
+  return match ? match[0] : flat;
+}
+
+function itemLine(key, item) {
+  if (key === 'finished' && item.detail) return clip(firstSentence(item.detail), 90);
+  if (key === 'merged') return item.link ? `${clip(item.title, 70)}  ${item.link}` : clip(item.title, 90);
+  if (key === 'turned_down') return item.reason ? `${clip(item.title, 50)}: ${clip(item.reason, 70)}` : clip(item.title, 90);
+  return clip(item.title, 90);
+}
+
+function formatReport(report) {
+  const lines = ['', `what the team did since ${report.since}`];
+  if (!report.members.length) {
+    lines.push('', '  nothing merged, finished, turned down, or done since then.', '');
+    return lines.join('\n');
+  }
+  lines.push(GROUPS.map(([key, label]) => `${report.totals[key]} ${label}`).join(', '));
+  for (const row of report.members) {
+    lines.push('', row.member);
+    for (const [key, label] of GROUPS) {
+      const list = row[key];
+      list.slice(0, PER_GROUP).forEach((item, index) => {
+        lines.push(`  ${(index === 0 ? label : '').padEnd(15)}${itemLine(key, item)}`);
+      });
+      if (list.length > PER_GROUP) lines.push(`  ${''.padEnd(15)}and ${list.length - PER_GROUP} more`);
+    }
+  }
+  lines.push('');
+  return lines.join('\n');
+}
+
+function loadTasks(root) {
+  try {
+    const taskDb = require('./task-db');
+    return taskDb.listTasks(taskDb.open(), { workspaceRoot: taskDb.workspaceRoot(root) });
+  } catch {
+    return [];
+  }
+}
+
+function memberReportCommand(...args) {
+  let parsed;
+  try {
+    parsed = parseReportArgs(args);
+  } catch (error) {
+    console.error(error.message);
+    process.exitCode = 1;
+    return null;
+  }
+  if (parsed.help) {
+    console.log(usage());
+    return null;
+  }
+  let report;
+  try {
+    const root = process.cwd();
+    report = memberReport(root, { since: parsed.since, tasks: loadTasks(root) });
+  } catch (error) {
+    console.error(error.message);
+    process.exitCode = 1;
+    return null;
+  }
+  console.log(parsed.json ? JSON.stringify(report, null, 2) : formatReport(report));
+  return report;
+}
+
+module.exports = {
+  formatReport,
+  memberReport,
+  memberReportCommand,
+  parseSince,
+};

package/lib/member-scaffold.js

@@ -139,8 +139,7 @@ function initialMemberLog({ name, role, description, source, now }) {
     description ? `- mission: ${description}` : '',
     `- source: ${source}`,
     '- status: ready_for_room',
-    '',
-  ].filter(Boolean).join('\n');
+  ].filter(Boolean).join('\n') + '\n';
 }
 
 function ensureMemberBundle(memberDir, {

package/lib/member-switches.js

@@ -64,6 +64,12 @@ function isMemberAwake(name, root = process.cwd()) {
   return getMemberSwitch(name, root).awake !== false;
 }
 
+// Names of members whose switch is off, so boards can show them asleep.
+function asleepMembers(root = process.cwd()) {
+  const { members } = loadMemberSwitches(root);
+  return Object.keys(members).filter((name) => normalizeMemberEntry(members[name]).awake === false).sort();
+}
+
 function isMemberLoopAwake(name, loopId, root = process.cwd()) {
   const entry = getMemberSwitch(name, root);
   if (entry.awake === false) return false;
@@ -132,6 +138,7 @@ module.exports = {
   isLocalMember,
   getMemberSwitch,
   isMemberAwake,
+  asleepMembers,
   setMemberAwake,
   setMemberLoopAwake,
   readLoopFlag,

package/lib/task-db.js

@@ -454,6 +454,21 @@ function addTask(db, { title, tag, workspaceRoot: ws, sourceKey: sk, metadata, s
   return { id, inserted: true };
 }
 
+// Same job = same title ignoring case and spacing. Only jobs not yet handed in
+// (open or claimed) count, so a job in review, done, or failed can be filed again.
+function normalizeTaskTitle(title) {
+  return String(title || '').trim().replace(/\s+/g, ' ').toLowerCase();
+}
+
+function findUnfinishedTaskByTitle(db, { workspaceRoot: ws, title }) {
+  const wanted = normalizeTaskTitle(title);
+  if (!wanted) return null;
+  const rows = db.prepare(
+    "SELECT id, title FROM tasks WHERE workspace_root = ? AND status IN ('open', 'claimed') ORDER BY created_at ASC"
+  ).all(ws);
+  return rows.find((row) => normalizeTaskTitle(row.title) === wanted) || null;
+}
+
 // A main checkout's view also covers its linked git worktrees, whose tasks keep
 // the worktree as workspace_root so checks run where the work lives. Only a
 // main checkout with linked worktrees spawns git; any error means exact match.
@@ -2304,6 +2319,7 @@ module.exports = {
   sourceKey,
   normalizeTitle,
   addTask,
+  findUnfinishedTaskByTitle,
   getTask,
   listTasks,
   listTasksCached,

package/package.json

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