atris 3.68.1 → 3.68.3

package/lib/first-minute.js

@@ -272,6 +272,25 @@ function taskNextCommand(tasks, person) {
   return picked.command;
 }
 
+// A person's first talk mints an onboarding task in their own words. That task
+// is the human's thing; the init seed ("Generate MAP.md, ...") is agent setup.
+function isHumanStarter(task) {
+  const metadata = (task && task.metadata) || {};
+  return Boolean(task) && (metadata.source === 'context_gatherer' || task.tag === 'onboarding');
+}
+
+function isInitSeedTask(task) {
+  return Boolean(task && task.metadata && task.metadata.source === 'init_seed');
+}
+
+// In a room a person started by talking, the open init seed is not their next
+// step. Agents still find it on the task plane; the human screens skip it.
+function withoutSeedForHumans(tasks) {
+  const list = Array.isArray(tasks) ? tasks : [];
+  if (!list.some(isHumanStarter)) return list;
+  return list.filter((task) => !(isInitSeedTask(task) && task.status === 'open'));
+}
+
 function pickNext({
   tasks = [],
   missions = [],
@@ -281,6 +300,7 @@ function pickNext({
   inboxCount = 0,
   wipCount = 0,
 } = {}) {
+  tasks = withoutSeedForHumans(tasks);
   const reviews = (Array.isArray(tasks) ? tasks : []).filter((task) => task && task.status === 'review');
   const certified = newest(reviews.filter(isCertifiedReview));
   if (certified) return { task: certified, command: taskCommand(certified, person) };
@@ -361,6 +381,94 @@ function spokenVisibleNames(files) {
   return names.sort((a, b) => a.localeCompare(b));
 }
 
+const BUILT_SKIP_DIRS = new Set(['atris', 'node_modules']);
+const BUILT_MAX_FILES = 500;
+const BUILT_MAX_DEPTH = 6;
+
+function toMs(value) {
+  if (value == null || value === '') return 0;
+  const n = Number(value);
+  if (Number.isFinite(n)) return n;
+  const parsed = Date.parse(String(value));
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function taskStartedAt(task) {
+  return toMs(task && task.claimed_at) || toMs(task && task.created_at);
+}
+
+// Files a person can see that were written after `sinceMs`: what their coding
+// agent built. atris/, .atris/, node_modules, and dotfiles are not the work.
+function listBuiltSince(root = process.cwd(), sinceMs = 0) {
+  const base = path.resolve(root || '.');
+  const since = Number(sinceMs) || 0;
+  const found = [];
+  let seen = 0;
+  const walk = (dir, rel, depth) => {
+    if (depth > BUILT_MAX_DEPTH || seen >= BUILT_MAX_FILES) return;
+    let entries = [];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (seen >= BUILT_MAX_FILES) return;
+      const name = entry.name;
+      if (!isUserVisibleName(name) || name === LATER_NOTE_FILE) continue;
+      if (depth === 0 && BUILT_SKIP_DIRS.has(name)) continue;
+      if (name === 'node_modules') continue;
+      const full = path.join(dir, name);
+      const relPath = rel ? `${rel}/${name}` : name;
+      if (entry.isDirectory()) {
+        walk(full, relPath, depth + 1);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      seen += 1;
+      let stat;
+      try {
+        stat = fs.statSync(full);
+      } catch {
+        continue;
+      }
+      if (stat.mtimeMs >= since) found.push(relPath);
+    }
+  };
+  walk(base, '', 0);
+  return found.sort((a, b) => a.localeCompare(b));
+}
+
+// The thing to open: an index.html (shallowest first), else the first file.
+function mainBuiltFile(files) {
+  const list = Array.isArray(files) ? files : [];
+  const pages = list
+    .filter((file) => /(^|\/)index\.html?$/i.test(file))
+    .sort((a, b) => a.split('/').length - b.split('/').length || a.localeCompare(b));
+  return pages[0] || list[0] || '';
+}
+
+function orderBuilt(files) {
+  const list = Array.isArray(files) ? [...files] : [];
+  const main = mainBuiltFile(list);
+  if (!main) return list;
+  return [main, ...list.filter((file) => file !== main)];
+}
+
+function spokenBuiltList(files, max = 3) {
+  const list = orderBuilt(files);
+  if (list.length <= max) return list.join(', ');
+  return `${list.slice(0, max).join(', ')} and ${list.length - max} more`;
+}
+
+function humanStarterTask(tasks, person = '', { statuses = ['claimed', 'review'] } = {}) {
+  const list = (Array.isArray(tasks) ? tasks : [])
+    .filter((task) => isHumanStarter(task) && statuses.includes(task.status));
+  const who = String(person || '').trim();
+  const mine = who ? list.filter((task) => String(task.claimed_by || '') === who) : [];
+  return newest(mine.length ? mine : list);
+}
+
 function spokenCommitSubject(value) {
   const text = clip(value, 72);
   if (text.endsWith('...')) return text;
@@ -619,13 +727,85 @@ function firstTalkJson({ starter = null, person = '', folder = 'this folder' } =
   };
 }
 
-function renderFirstTalk({ person = '', folder = 'this folder', starter = null } = {}) {
+// First talk only saves the want as a task. Say so, and make the one next step
+// the local coding agent that builds it, so a new person is never told work
+// exists when none does. Test runners get no probe (machine-independent output).
+const FIRST_TALK_BUILDERS = ['claude', 'codex', 'cursor-agent'];
+const FIRST_TALK_INSTALL = 'npm install -g @anthropic-ai/claude-code';
+
+function firstTalkBuilder(probe = (bin) => spawnSync('sh', ['-c', `command -v ${bin}`], { encoding: 'utf8' })) {
+  if (process.env.NODE_TEST_CONTEXT && arguments.length === 0) return undefined;
+  for (const bin of FIRST_TALK_BUILDERS) {
+    const result = probe(bin);
+    if (result && result.status === 0 && String(result.stdout || '').trim()) return bin;
+  }
+  return null;
+}
+
+function firstTalkBuildCommand(builder, want) {
+  if (builder === undefined) return '';
+  if (!builder) return FIRST_TALK_INSTALL;
+  const text = String(want || '').replace(/\s+/g, ' ').trim().replace(/(["\\$`])/g, '\\$1');
+  return `${builder} "${text}"`;
+}
+
+function renderFirstTalk({ person = '', folder = 'this folder', starter = null, builder } = {}) {
   const room = folder || 'this folder';
   const title = spokenStarterTitle(starter && starter.title, room);
+  const build = firstTalkBuildCommand(builder, (starter && starter.title) || title);
   return [
-    `${greet(person)}${title} is ready.`,
+    `${greet(person)}${title} is started. nothing is built yet.`,
     '',
-    `next: ${firstTalkNext({ starter, person, folder: room })}`,
+    `next: ${build || firstTalkNext({ starter, person, folder: room })}`,
+  ].join('\n');
+}
+
+const WHATS_NEXT_COMMAND = 'atris "what\'s next?"';
+
+function isWhatsNextLine(value) {
+  const text = String(value || '')
+    .trim()
+    .replace(/^atris\s+/i, '')
+    .replace(/^["']+|["']+$/g, '')
+    .toLowerCase()
+    .replace(/[?.!]+$/g, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+  return /^(what'?s|what is) next$/.test(text) || text === 'what next';
+}
+
+function starterTitle(task, folder = 'this folder') {
+  return spokenStarterTitle(clip(task && task.title, 80), folder);
+}
+
+function renderStarterNewWork({ person = '', task = null, files = [], folder = 'this folder' } = {}) {
+  return [
+    `${greet(person)}${starterTitle(task, folder)} has new work: ${spokenBuiltList(files)}.`,
+    '',
+    'next: atris done',
+  ].join('\n');
+}
+
+// The human's first want is landed and nothing else of theirs is live.
+function shippedHumanStarter(tasks) {
+  const list = Array.isArray(tasks) ? tasks : [];
+  if (list.some((task) => isHumanStarter(task) && isActionableTask(task))) return null;
+  return newest(list.filter((task) => isHumanStarter(task) && task.status === 'done'));
+}
+
+function renderStarterShipped({ person = '', task = null, folder = 'this folder' } = {}) {
+  return [
+    `${greet(person)}you already shipped ${starterTitle(task, folder)}.`,
+    '',
+    `next: ${WHATS_NEXT_COMMAND}`,
+  ].join('\n');
+}
+
+function renderWhatsNextAsk({ person = '', task = null, folder = 'this folder' } = {}) {
+  return [
+    `${greet(person)}${starterTitle(task, folder)} is shipped. say the next thing you want here, in your own words.`,
+    '',
+    'next: atris "<the next thing you want>"',
   ].join('\n');
 }
 
@@ -694,6 +874,7 @@ function buildFirstMinute({
   dirty,
   branch,
   later,
+  builder,
 } = {}) {
   const who = person != null ? person : personName();
   const room = folder != null ? folder : folderName(root);
@@ -718,8 +899,16 @@ function buildFirstMinute({
     };
   }
   const tasks = loadLocalTasks(root);
-  const todoBacklog = titlesFromTodoSection(root, 'Backlog');
-  const todoWip = titlesFromTodoSection(root, 'In Progress');
+  // The rendered TODO.md still lists the init seed; in a person's room it is
+  // not their waiting work either.
+  const seedTitles = tasks.some(isHumanStarter)
+    ? new Set(tasks.filter(isInitSeedTask).map((task) => String(task.title || '').trim().toLowerCase()))
+    : null;
+  const notSeed = (titles) => (titles && seedTitles
+    ? titles.filter((title) => !seedTitles.has(String(title || '').trim().toLowerCase()))
+    : titles);
+  const todoBacklog = notSeed(titlesFromTodoSection(root, 'Backlog'));
+  const todoWip = notSeed(titlesFromTodoSection(root, 'In Progress'));
   const backlogCount = todoBacklog
     ? todoBacklog.length
     : (Array.isArray(context.backlogTasks) ? context.backlogTasks.length : 0);
@@ -749,6 +938,55 @@ function buildFirstMinute({
     wipCount,
     inboxCount,
   });
+  // The person's own first want, claimed: if their coding agent built
+  // something since, the next step is `atris done`. If nothing is built yet,
+  // the next step is the builder, not a task-plane ready line.
+  if (picked.task && picked.task.status === 'claimed' && isHumanStarter(picked.task)) {
+    const built = listBuiltSince(root, taskStartedAt(picked.task));
+    if (built.length) {
+      return {
+        kind: 'workspace',
+        text: renderStarterNewWork({ person: who, task: picked.task, files: built, folder: room }),
+        nextCommand: 'atris done',
+        task: picked.task,
+        recap,
+        starter: true,
+        built,
+      };
+    }
+    const build = firstTalkBuildCommand(
+      builder !== undefined ? builder : firstTalkBuilder(),
+      picked.task.title,
+    );
+    if (build) {
+      return {
+        kind: 'workspace',
+        text: renderWorkspace({
+          person: who,
+          folder: room,
+          task: picked.task,
+          recap,
+          nextCommand: build,
+          liveWork,
+        }),
+        nextCommand: build,
+        task: picked.task,
+        recap,
+        starter: true,
+      };
+    }
+  }
+  const shipped = !picked.task && !picked.mission && !liveWork ? shippedHumanStarter(tasks) : null;
+  if (shipped) {
+    return {
+      kind: 'workspace',
+      text: renderStarterShipped({ person: who, task: shipped, folder: room }),
+      nextCommand: WHATS_NEXT_COMMAND,
+      task: null,
+      recap,
+      shipped,
+    };
+  }
   return {
     kind: 'workspace',
     text: renderWorkspace({
@@ -863,7 +1101,8 @@ function spokenWinReason(text) {
 
 function isKeepWorkingMinute(minute) {
   const next = String((minute && minute.nextCommand) || '');
-  if (next === 'atris do') return true;
+  if (next === 'atris do' || next === 'atris done') return true;
+  if (minute && (minute.starter || minute.shipped)) return true;
   return isClaimedKeepWorkingCommand(next);
 }
 
@@ -913,12 +1152,24 @@ module.exports = {
   isCertifiedReview,
   isFirstTalkLine,
   isFreshWorkspace,
+  isWhatsNextLine,
+  humanStarterTask,
+  listBuiltSince,
+  mainBuiltFile,
+  orderBuilt,
+  shippedHumanStarter,
+  spokenBuiltList,
+  taskStartedAt,
+  loadLocalTasks,
+  firstTalkBuildCommand,
+  renderWhatsNextAsk,
   isLeftoverVerbLook,
   isTaskNextLook,
   listUserVisibleWork,
   personName,
   pickNext,
   renderFirstTalk,
+  firstTalkBuilder,
   renderLaterRemember,
   spokenLaterNote,
   visibleWorkTitle,