atris 3.68.9 → 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/member-task-pick.js

@@ -0,0 +1,116 @@
+'use strict';
+
+// The next real job for a member with no idea given: the oldest open,
+// unclaimed task in this workspace whose job (build, review, search) matches
+// the member's, held neither for a human nor in a protected lane. Callers
+// fall back to the member's own goal when this returns null, unless they
+// ask for requireCheck: then only tasks with a runnable check count, and
+// nothing found means the member stays idle.
+
+const { autoJobForMember } = require('./member-engine');
+const { deniedTagOf, declaredProtectedLane, sniffedProtectedLane, isAutoCertifyVerifyCommandAllowed } = require('./auto-accept-certified');
+const { isDecisionHoldTag, isDecisionTask, taskTagTokens } = require('./task-decision');
+
+// A task's job uses the member rule with its tags in the name slot and its
+// title in the role slot: tags decide first, then the title, else build.
+function jobForTask(task) {
+  return autoJobForMember(taskTagTokens(task).join(' '), task && task.title);
+}
+
+function taskBody(task) {
+  const meta = (task && task.metadata) || {};
+  return ['objective', 'body', 'description', 'details']
+    .map((key) => (typeof meta[key] === 'string' ? meta[key].trim() : ''))
+    .find(Boolean) || '';
+}
+
+// The objective a member run gets: the title, then the body when there is one,
+// on one line. Mission start refuses objectives with line breaks.
+function taskObjective(task) {
+  const oneLine = (text) => String(text || '').replace(/\s+/g, ' ').trim();
+  const title = oneLine(task && task.title);
+  const body = oneLine(taskBody(task));
+  if (!body) return title;
+  return /[.!?]$/.test(title) ? `${title} ${body}` : `${title}. ${body}`;
+}
+
+// Held for a person: a denied tag on the row or in its metadata, a protected
+// lane declared anywhere in its text, or lane terms in its title or body.
+// Tags written in metadata, which the shared tag parser does not read.
+function metadataTags(task) {
+  const meta = (task && task.metadata) || {};
+  return [meta.tag, ...(Array.isArray(meta.tags) ? meta.tags : [])]
+    .filter((t) => typeof t === 'string' && t.trim())
+    .map((t) => t.trim().toLowerCase().replace(/^#/, ''));
+}
+
+function protectedTask(task) {
+  const meta = (task && task.metadata) || {};
+  const tags = [...metadataTags(task), ...taskTagTokens(task)];
+  if (deniedTagOf(task) || tags.some((tag) => deniedTagOf({ tag }))) return true;
+  // Every text field, not just the one the objective uses.
+  const allText = ['objective', 'body', 'description', 'details']
+    .map((key) => (typeof meta[key] === 'string' ? meta[key] : ''))
+    .filter(Boolean)
+    .join('\n');
+  const probe = { title: task.title, objective: allText, metadata: meta };
+  return Boolean(declaredProtectedLane(probe) || sniffedProtectedLane(probe));
+}
+
+// The check a task requires, when it names one. A check written as prose
+// that cannot be run means the task cannot be proven here.
+function taskCheck(task) {
+  const verify = task && task.metadata && typeof task.metadata.verify === 'string'
+    ? task.metadata.verify.trim() : '';
+  if (!verify) return { command: '', runnable: true };
+  return { command: verify, runnable: isAutoCertifyVerifyCommandAllowed(verify) };
+}
+
+function skipReason(task, job, { requireCheck = false } = {}) {
+  if (!task || task.status !== 'open') return 'not_open';
+  if (task.claimed_by) return 'claimed';
+  if (isDecisionTask(task) || metadataTags(task).some(isDecisionHoldTag)) return 'needs_human';
+  if (protectedTask(task)) return 'protected_lane';
+  const check = taskCheck(task);
+  if (!check.runnable) return 'check_not_runnable';
+  if (requireCheck && !check.command) return 'no_check';
+  if (jobForTask(task) !== job) return 'other_job';
+  return '';
+}
+
+function fittingTasks(taskDb, db, { workspaceRoot, job, requireCheck = false }) {
+  return taskDb.listTasks(db, { workspaceRoot, status: 'open' })
+    .filter((task) => !skipReason(task, job, { requireCheck }))
+    .sort((a, b) => (a.created_at - b.created_at) || String(a.id).localeCompare(String(b.id)));
+}
+
+function pickTaskForMember(taskDb, db, { workspaceRoot, job, requireCheck = false }) {
+  return fittingTasks(taskDb, db, { workspaceRoot, job, requireCheck })[0] || null;
+}
+
+// Claim the oldest fitting task for the member. A lost race moves on to the
+// next candidate; null when nothing fits or every claim lost.
+function claimTaskForMember(taskDb, db, { workspaceRoot, member, job, requireCheck = false }) {
+  for (const task of fittingTasks(taskDb, db, { workspaceRoot, job, requireCheck })) {
+    let result;
+    try {
+      result = taskDb.claimTask(db, { id: task.id, claimedBy: member });
+    } catch (error) {
+      // A claim that half-wrote must not strand the task.
+      try { taskDb.releaseTask(db, { id: task.id, actor: member }); } catch {}
+      throw error;
+    }
+    if (result.claimed) return { task: result.row, objective: taskObjective(result.row) };
+  }
+  return null;
+}
+
+module.exports = {
+  taskCheck,
+  claimTaskForMember,
+  fittingTasks,
+  jobForTask,
+  pickTaskForMember,
+  skipReason,
+  taskObjective,
+};