atris 3.34.0 → 3.36.0

package/commands/gm.js

@@ -6,6 +6,8 @@ const path = require('path');
 
 const AGENTXP_LEADERBOARD_URL = 'https://api.atris.ai/api/agentxp/leaderboard';
 const AGENTXP_GLOBAL_SYNC_RULE = 'Run atris login, then sync. Owner-provided sync tokens are guided-demo fallback only.';
+const GM_WATCH_DEFAULT_INTERVAL_SECONDS = 10;
+const GM_WATCH_CONTENT_LIMIT = 180;
 
 const ROLE_PLAYERS_TO_IGNORE = new Set([
   'game-manager',
@@ -21,17 +23,21 @@ const ROLE_PLAYERS_TO_IGNORE = new Set([
 function showHelp() {
   console.log('');
   console.log('Usage: atris gm [--manager <id>] [--player <id>] [--workspace <path>] [--json]');
+  console.log('       atris gm --watch [--interval 10]');
   console.log('');
   console.log('Description:');
   console.log('  Enter AgentXP General Manager mode for the current Atris workspace.');
   console.log('  Shows local players, active missions, review queue, and the next command');
   console.log('  that moves the same AgentXP game loop forward.');
+  console.log('  Watch mode keeps that first board, then appends new mission, review, and feed events.');
   console.log('');
   console.log('Options:');
   console.log('  --manager <id>    Manager id. Defaults to game-manager when present.');
   console.log('  --as <id>         Alias for --player.');
   console.log('  --player <id>     Preferred player when seeding a first local mission.');
   console.log('  --workspace <p>   Read missions from another Atris workspace.');
+  console.log('  --watch           Append new GM events until Ctrl+C.');
+  console.log('  --interval <sec>  Watch polling interval. Defaults to 10.');
   console.log('  --no-seed         Do not create a starter player mission.');
   console.log('  --json            Print machine-readable mode state.');
   console.log('  --help, -h        Show this help.');
@@ -294,17 +300,25 @@ function nextCommands({ seeded, reviewQueue, missions, players, manager }) {
   return ['atris gm --player <player>'];
 }
 
-function gmState(args = []) {
+function readGmTaskRows(args = []) {
   const taskDb = require('../lib/task-db');
   const workspaceArg = flag(args, '--workspace') || flag(args, '--root') || process.cwd();
   const workspaceRoot = taskDb.workspaceRoot(path.resolve(workspaceArg));
   const db = taskDb.open();
-  let tasks = taskDb.withTaskDisplayRefs(taskDb.listTasks(db, {
+  const tasks = taskDb.withTaskDisplayRefs(taskDb.listTasks(db, {
     workspaceRoot,
     limit: 500,
   }));
+  return { taskDb, db, workspaceRoot, tasks };
+}
+
+function gmState(args = [], options = {}) {
+  const { taskDb, db, workspaceRoot, tasks: initialTasks } = readGmTaskRows(args);
+  let tasks = initialTasks;
   const detected = inferManager(workspaceRoot, args);
-  const starter = ensureStarterMission(taskDb, db, workspaceRoot, tasks, args);
+  const starter = options.seed === false
+    ? { tasks, seeded: null }
+    : ensureStarterMission(taskDb, db, workspaceRoot, tasks, args);
   tasks = starter.tasks;
 
   const missions = activeAgentXpTasks(tasks).map(compactTask);
@@ -337,6 +351,247 @@ function gmState(args = []) {
   };
 }
 
+function watchIntervalSeconds(args = []) {
+  const raw = flag(args, '--interval');
+  const parsed = parseInt(raw || String(GM_WATCH_DEFAULT_INTERVAL_SECONDS), 10);
+  return Number.isFinite(parsed) ? Math.max(1, parsed) : GM_WATCH_DEFAULT_INTERVAL_SECONDS;
+}
+
+function watchStamp(value) {
+  const date = value ? new Date(value) : new Date();
+  const safe = Number.isFinite(date.getTime()) ? date : new Date();
+  return safe.toTimeString().slice(0, 5);
+}
+
+function eventMs(value) {
+  const ms = value ? Date.parse(value) : NaN;
+  return Number.isFinite(ms) ? ms : Date.now();
+}
+
+function watchLine(event) {
+  const name = String(event.name || event.kind || 'event').replace(/\s+/g, ' ').trim();
+  const content = clip(event.content || '', GM_WATCH_CONTENT_LIMIT);
+  return `[${watchStamp(event.at)}] [${event.kind}] ${name}: ${content}`;
+}
+
+function missionShortId(mission) {
+  const id = String(mission && mission.id || '');
+  if (!id) return 'mission';
+  return id.length > 20 ? `...${id.slice(-8)}` : id;
+}
+
+function missionFingerprint(mission) {
+  return [
+    mission && mission.status,
+    mission && mission.last_tick_at,
+    mission && mission.last_tick_index,
+    mission && mission.receipt_path,
+  ].join('|');
+}
+
+function missionEvent(mission) {
+  let heartbeat = '';
+  try {
+    const { missionHeartbeatLines } = require('./mission');
+    heartbeat = missionHeartbeatLines(mission).map(line => line.trim()).join(', ');
+  } catch {
+    heartbeat = '';
+  }
+  const title = mission.objective || mission.slug || mission.id || 'mission';
+  return {
+    id: `mission:${mission.id}`,
+    kind: 'mission',
+    name: mission.owner || mission.slug || 'mission',
+    at: mission.last_tick_at || mission.updated_at || mission.created_at,
+    content: [
+      missionShortId(mission),
+      `[${mission.status || 'unknown'}]`,
+      heartbeat || null,
+      clip(title, 100),
+    ].filter(Boolean).join(' - '),
+    fingerprint: missionFingerprint(mission),
+  };
+}
+
+function taskMissionFingerprint(task) {
+  return [
+    task && task.status,
+    task && task.updated_at,
+    task && task.claimed_by,
+    task && task.done_at,
+  ].join('|');
+}
+
+function taskMissionEvent(task) {
+  const player = taskAssignee(task) || task.claimed_by || 'unassigned';
+  return {
+    id: `task:${task.id}`,
+    kind: 'mission',
+    name: player,
+    at: task.updated_at ? new Date(Number(task.updated_at)).toISOString() : null,
+    content: `${taskRef(task)} [${task.status || 'unknown'}] ${task.title || 'untitled task'}`,
+    fingerprint: taskMissionFingerprint(task),
+  };
+}
+
+function reviewEvent(task) {
+  const player = task.assigned_to || taskAssignee(task) || task.claimed_by || 'review';
+  return {
+    id: task.id,
+    kind: 'review',
+    name: player,
+    at: task.updated_at ? new Date(Number(task.updated_at)).toISOString() : null,
+    content: `${task.ref || taskRef(task)} ready - ${task.title || 'untitled task'}`,
+  };
+}
+
+function feedPostId(post) {
+  return String(post.id || post.post_id || `${post.created_at || ''}:${post.author_id || ''}:${post.content || ''}`);
+}
+
+function credentialsFileExists() {
+  return fs.existsSync(path.join(os.homedir(), '.atris', 'credentials.json'));
+}
+
+async function fetchFeedEvents(workspaceRoot) {
+  if (!credentialsFileExists()) return [];
+  let feed;
+  let loadCredentials;
+  try {
+    feed = require('./feed');
+    loadCredentials = require('../utils/auth').loadCredentials;
+  } catch {
+    return [];
+  }
+  if (
+    typeof feed.findBusiness !== 'function'
+    || typeof feed.fetchPosts !== 'function'
+    || typeof feed.authorLabel !== 'function'
+  ) {
+    return [];
+  }
+  const business = feed.findBusiness(workspaceRoot);
+  if (!business) return [];
+  const credentials = loadCredentials();
+  if (!credentials || !credentials.token) return [];
+  const aliases = typeof feed.loadAuthorAliases === 'function' ? feed.loadAuthorAliases(business.root) : {};
+  const posts = await feed.fetchPosts(business.businessId, credentials.token, 20);
+  return posts.map((post) => {
+    const id = feedPostId(post);
+    return {
+      id,
+      kind: 'feed',
+      name: feed.authorLabel(post, aliases, credentials.user_id, credentials.email),
+      at: post.created_at,
+      content: String(post.content || '').replace(/\s+/g, ' ').trim(),
+    };
+  });
+}
+
+function collectLocalWatchState(args = []) {
+  const { workspaceRoot, tasks } = readGmTaskRows(args);
+  const taskMissions = activeAgentXpTasks(tasks);
+  const reviewQueue = taskMissions.filter(task => task.status === 'review');
+  return { workspaceRoot, taskMissions, reviewQueue };
+}
+
+function listDurableMissions(workspaceRoot) {
+  try {
+    const { listMissions } = require('./mission');
+    if (typeof listMissions !== 'function') return [];
+    return listMissions(workspaceRoot);
+  } catch {
+    return [];
+  }
+}
+
+async function gmWatchSnapshot(args) {
+  const local = collectLocalWatchState(args);
+  const durableMissions = listDurableMissions(local.workspaceRoot);
+  const feedEvents = await fetchFeedEvents(local.workspaceRoot);
+  return {
+    reviewEvents: local.reviewQueue.map(reviewEvent),
+    missionEvents: [
+      ...local.taskMissions.map(taskMissionEvent),
+      ...durableMissions.map(missionEvent),
+    ],
+    feedEvents,
+  };
+}
+
+function markSnapshotSeen(snapshot, seen) {
+  for (const event of snapshot.missionEvents) seen.missions.set(event.id, event.fingerprint);
+  for (const event of snapshot.reviewEvents) seen.reviews.add(event.id);
+  for (const event of snapshot.feedEvents) seen.feed.add(event.id);
+}
+
+function newWatchEvents(snapshot, seen) {
+  const events = [];
+  for (const event of snapshot.missionEvents) {
+    const previous = seen.missions.get(event.id);
+    if (previous !== event.fingerprint) {
+      events.push(event);
+      seen.missions.set(event.id, event.fingerprint);
+    }
+  }
+  for (const event of snapshot.reviewEvents) {
+    if (!seen.reviews.has(event.id)) {
+      events.push(event);
+      seen.reviews.add(event.id);
+    }
+  }
+  for (const event of snapshot.feedEvents) {
+    if (!seen.feed.has(event.id)) {
+      events.push(event);
+      seen.feed.add(event.id);
+    }
+  }
+  return events.sort((a, b) => eventMs(a.at) - eventMs(b.at));
+}
+
+async function gmWatch(args = []) {
+  const intervalSeconds = watchIntervalSeconds(args);
+  const seen = {
+    missions: new Map(),
+    reviews: new Set(),
+    feed: new Set(),
+  };
+  try {
+    markSnapshotSeen(await gmWatchSnapshot(args), seen);
+  } catch {
+    // Watch mode is append-only; transient read failures should not redraw or exit.
+  }
+
+  console.log('');
+  console.log(`Watching GM events every ${intervalSeconds}s. Ctrl+C to stop.`);
+  console.log('');
+
+  let polling = false;
+  const poll = async () => {
+    if (polling) return;
+    polling = true;
+    try {
+      const events = newWatchEvents(await gmWatchSnapshot(args, seen), seen);
+      for (const event of events) console.log(watchLine(event));
+    } catch {
+      // Match fleet watch: quiet on transient poll failures.
+    } finally {
+      polling = false;
+    }
+  };
+
+  const interval = setInterval(poll, intervalSeconds * 1000);
+  return new Promise((resolve) => {
+    const onSigint = () => {
+      clearInterval(interval);
+      process.off('SIGINT', onSigint);
+      console.log('\nStopped watching.\n');
+      resolve();
+    };
+    process.on('SIGINT', onSigint);
+  });
+}
+
 function render(state) {
   console.log('');
   console.log('AgentXP General Manager');
@@ -374,21 +629,48 @@ function render(state) {
   for (const command of state.next_commands) console.log(`- ${command}`);
 }
 
+// `gm <name>` is how people greet a team member in chat ("gm maze"). When the
+// positional names a real member (and not the manager persona), the same phrase
+// works in the terminal: wake that member instead of entering manager mode.
+function wakeableMember(args) {
+  const name = slugify(positional(args)[0]);
+  if (!name || name === 'game-manager' || flag(args, '--manager')) return null;
+  const memberDir = path.join(process.cwd(), 'atris', 'team', name);
+  if (!fs.existsSync(path.join(memberDir, 'MEMBER.md'))) return null;
+  return name;
+}
+
 async function gmCommand(...args) {
   if (args.includes('--help') || args.includes('-h') || args[0] === 'help') {
     showHelp();
     return;
   }
 
+  const member = wakeableMember(args);
+  if (member) {
+    const { isMemberAwake } = require('../lib/member-switches');
+    if (!isMemberAwake(member)) {
+      console.log(`${member} is asleep`);
+      return;
+    }
+    const { memberCommand } = require('./member');
+    const passthrough = args.filter(arg => arg !== member);
+    return memberCommand('wake', member, ...passthrough);
+  }
+
   const state = gmState(args);
   if (hasFlag(args, '--json')) {
     console.log(JSON.stringify(state, null, 2));
     return;
   }
   render(state);
+  if (hasFlag(args, '--watch')) {
+    await gmWatch(args);
+  }
 }
 
 module.exports = {
   gmCommand,
   gmState,
+  gmWatchSnapshot,
 };

package/commands/goal.js

@@ -0,0 +1,247 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const SCOREBOARD_FILE = path.join('.atris', 'state', 'scoreboard.json');
+const TASK_PROJECTION_FILE = path.join('.atris', 'state', 'tasks.projection.json');
+
+function normalizeText(value) {
+  return String(value || '')
+    .replace(/[\u2013\u2014]/g, '-')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .toLowerCase();
+}
+
+function scoreboardPath(root = process.cwd()) {
+  return path.join(root, SCOREBOARD_FILE);
+}
+
+function emptyScoreboard() {
+  return { goal: null, metrics: [], updated_at: null };
+}
+
+function readScoreboard(root = process.cwd()) {
+  const file = scoreboardPath(root);
+  if (!fs.existsSync(file)) return emptyScoreboard();
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return {
+      goal: normalizeText(parsed?.goal) || null,
+      metrics: Array.isArray(parsed?.metrics)
+        ? parsed.metrics
+          .map((metric) => ({
+            name: normalizeText(metric?.name),
+            value: normalizeText(metric?.value),
+          }))
+          .filter((metric) => metric.name && metric.value)
+        : [],
+      updated_at: parsed?.updated_at || null,
+    };
+  } catch {
+    return emptyScoreboard();
+  }
+}
+
+function writeScoreboard(scoreboard, root = process.cwd()) {
+  const file = scoreboardPath(root);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const next = {
+    goal: normalizeText(scoreboard.goal),
+    metrics: Array.isArray(scoreboard.metrics) ? scoreboard.metrics : [],
+    updated_at: new Date().toISOString(),
+  };
+  const temp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(temp, `${JSON.stringify(next)}\n`, 'utf8');
+  fs.renameSync(temp, file);
+  return next;
+}
+
+function timestampMs(value) {
+  if (value === null || value === undefined || value === '') return null;
+  const numeric = Number(value);
+  if (Number.isFinite(numeric)) return numeric;
+  const parsed = new Date(value).getTime();
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function localDateKey(value) {
+  const ms = timestampMs(value);
+  if (ms === null) return null;
+  const date = new Date(ms);
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  return `${year}-${month}-${day}`;
+}
+
+function taskDoneTime(task) {
+  if (task?.done_at) return task.done_at;
+  const events = Array.isArray(task?.events) ? task.events : [];
+  const done = [...events].reverse().find((event) => ['completed', 'done', 'accepted'].includes(
+    normalizeText(event?.event_type),
+  ));
+  return done?.created_at || null;
+}
+
+function readTaskMovement(root = process.cwd(), now = new Date()) {
+  const file = path.join(root, TASK_PROJECTION_FILE);
+  if (!fs.existsSync(file)) return { available: false, landed: 0, review: 0 };
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (!Array.isArray(parsed?.tasks)) return { available: false, landed: 0, review: 0 };
+    const today = localDateKey(now);
+    return {
+      available: true,
+      landed: parsed.tasks.filter((task) => (
+        normalizeText(task?.status) === 'done'
+        && localDateKey(taskDoneTime(task)) === today
+      )).length,
+      review: parsed.tasks.filter((task) => normalizeText(task?.status) === 'review').length,
+    };
+  } catch {
+    return { available: false, landed: 0, review: 0 };
+  }
+}
+
+function readMissionMovement(root = process.cwd(), now = new Date()) {
+  const file = path.join(root, '.atris', 'state', 'missions.jsonl');
+  if (!fs.existsSync(file)) return { available: false, completed: 0 };
+  try {
+    const { listMissions } = require('./mission');
+    const today = localDateKey(now);
+    const completed = listMissions(root).filter((mission) => (
+      ['complete', 'completed'].includes(normalizeText(mission?.status))
+      && localDateKey(mission?.completed_at || mission?.updated_at) === today
+    )).length;
+    return { available: true, completed };
+  } catch {
+    return { available: false, completed: 0 };
+  }
+}
+
+function plural(count, singular) {
+  return `${count} ${singular}${count === 1 ? '' : 's'}`;
+}
+
+function todayText(tasks, missions) {
+  const parts = [];
+  if (tasks.available) {
+    parts.push(`${plural(tasks.landed, 'task')} landed`);
+    parts.push(`${tasks.review} waiting for your ok`);
+  }
+  if (missions.available) parts.push(`${plural(missions.completed, 'mission')} completed`);
+  return parts.length ? parts.join(', ') : 'no movement recorded today';
+}
+
+function buildGoalView(root = process.cwd(), now = new Date()) {
+  const scoreboard = readScoreboard(root);
+  const tasks = readTaskMovement(root, now);
+  const missions = readMissionMovement(root, now);
+  const today = todayText(tasks, missions);
+  const next = tasks.review > 0
+    ? 'atris task reviews'
+    : scoreboard.goal
+      ? 'atris task day'
+      : 'atris goal set "<sentence>"';
+  return {
+    goal: scoreboard.goal,
+    metrics: scoreboard.metrics,
+    today,
+    next,
+  };
+}
+
+function row(label, value) {
+  return `  ${label.padEnd(10)}${value}`;
+}
+
+function renderGoalView(view) {
+  const goal = view.goal || 'goal not set. set it: atris goal set "<sentence>"';
+  const lines = [row('goal', goal)];
+  if (view.metrics.length > 0) {
+    lines.push(row('distance', view.metrics.map((metric) => `${metric.name}: ${metric.value}`).join(' | ')));
+  }
+  lines.push(row('today', view.today));
+  lines.push(row('next', view.next));
+  return lines.join('\n');
+}
+
+function printHelp() {
+  console.log('usage: atris goal [--json]');
+  console.log('       atris goal set "<sentence>"');
+  console.log('       atris goal metric <name> <value>');
+  console.log('       atris goal metric <name> --rm');
+}
+
+function run(args = [], context = {}) {
+  const root = context.cwd || process.cwd();
+  const now = context.now || new Date();
+  const command = args[0];
+
+  try {
+    if (args.includes('--help') || args.includes('-h') || command === 'help') {
+      printHelp();
+      return 0;
+    }
+
+    if (command === 'set') {
+      const goal = normalizeText(args.slice(1).join(' '));
+      if (!goal) {
+        console.error('error: goal sentence is required');
+        return 2;
+      }
+      const scoreboard = readScoreboard(root);
+      writeScoreboard({ ...scoreboard, goal }, root);
+      console.log('goal set.');
+      return 0;
+    }
+
+    if (command === 'metric') {
+      const name = normalizeText(args[1]);
+      if (!name) {
+        console.error('error: metric name is required');
+        return 2;
+      }
+      const scoreboard = readScoreboard(root);
+      const metrics = scoreboard.metrics.filter((metric) => metric.name !== name);
+      if (args.includes('--rm')) {
+        writeScoreboard({ ...scoreboard, metrics }, root);
+        console.log(`metric ${name} removed.`);
+        return 0;
+      }
+      const value = normalizeText(args.slice(2).join(' '));
+      if (!value) {
+        console.error('error: metric value is required');
+        return 2;
+      }
+      metrics.push({ name, value });
+      writeScoreboard({ ...scoreboard, metrics }, root);
+      console.log(`metric ${name} set.`);
+      return 0;
+    }
+
+    if (command && command !== '--json') {
+      console.error(`error: unknown goal command: ${normalizeText(command)}`);
+      return 2;
+    }
+
+    const view = buildGoalView(root, now);
+    console.log(args.includes('--json') ? JSON.stringify(view, null, 2) : renderGoalView(view));
+    return 0;
+  } catch (error) {
+    console.error(`error: ${normalizeText(error?.message || error)}`);
+    return 2;
+  }
+}
+
+module.exports = {
+  SCOREBOARD_FILE,
+  buildGoalView,
+  readScoreboard,
+  renderGoalView,
+  run,
+  scoreboardPath,
+  writeScoreboard,
+};