atris 3.38.0 → 3.41.0

package/lib/lesson-preflight.js

@@ -0,0 +1,146 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const ACTIVE_STATUSES = new Set(['observed', 'open', 'attempted']);
+const KEYWORD_STOP_WORDS = new Set([
+  'and', 'are', 'for', 'from', 'into', 'not', 'of', 'on', 'or', 'the', 'this', 'to', 'with', 'without',
+]);
+
+function readJson(filePath) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function readLessonText(filePath) {
+  let content = '';
+  try {
+    content = fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return new Map();
+  }
+
+  const bySlug = new Map();
+  for (const line of content.split(/\r?\n/)) {
+    const match = line.match(/^\s*-\s*\*\*\[([^\]]+)\]\s*([a-z0-9][a-z0-9-]*)\*\*\s*[—:-]+\s*(?:pass|fail)?\s*[—:-]*\s*(.*)$/i);
+    if (!match || bySlug.has(match[2])) continue;
+    const text = match[3].replace(/^\[resolved\]\s*/i, '').trim();
+    if (text) bySlug.set(match[2], text);
+  }
+  return bySlug;
+}
+
+function isPromptRule(mechanism) {
+  if (mechanism && typeof mechanism === 'object') {
+    const kind = String(mechanism.type || mechanism.kind || '').toLowerCase();
+    return kind === 'prompt-rule' || kind === 'prompt_rule' || mechanism.prompt_rule === true;
+  }
+  return /^\s*prompt[-_\s]?rule\b/i.test(String(mechanism || ''));
+}
+
+function lessonIsEligible(lesson) {
+  const status = String(lesson && lesson.status || '').toLowerCase();
+  if (ACTIVE_STATUSES.has(status)) return true;
+  return status === 'resolved' && isPromptRule(lesson.mechanism);
+}
+
+function normalizeFile(file) {
+  return String(file || '')
+    .trim()
+    .replace(/\\/g, '/')
+    .replace(/^\.\//, '')
+    .replace(/\/{2,}/g, '/')
+    .replace(/\/$/, '');
+}
+
+function pathSpecificity(file) {
+  const normalized = normalizeFile(file);
+  const segments = normalized.split('/').filter(Boolean).length;
+  return (segments * 100) + normalized.length;
+}
+
+function overlapStrength(appliesTo, file) {
+  const lessonPath = normalizeFile(appliesTo).toLowerCase();
+  const taskPath = normalizeFile(file).toLowerCase();
+  if (!lessonPath || !taskPath) return 0;
+  if (lessonPath === taskPath) return 3;
+  if (taskPath.endsWith(`/${lessonPath}`) || lessonPath.endsWith(`/${taskPath}`)) return 3;
+  if (taskPath.startsWith(`${lessonPath}/`) || lessonPath.startsWith(`${taskPath}/`)) return 2;
+  return 0;
+}
+
+function slugKeywords(slug) {
+  return [...new Set(String(slug || '').toLowerCase().split(/[^a-z0-9]+/)
+    .filter((word) => word.length >= 3 && !KEYWORD_STOP_WORDS.has(word)))];
+}
+
+function keywordAppears(text, keyword) {
+  const escaped = keyword.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return new RegExp(`(^|[^a-z0-9])${escaped}([^a-z0-9]|$)`, 'i').test(text);
+}
+
+function bestMatch({ slug, lesson, briefText, files }) {
+  const brief = String(briefText || '');
+  const briefLower = brief.toLowerCase().replace(/\\/g, '/');
+  const appliesTo = Array.isArray(lesson.applies_to) ? lesson.applies_to : [];
+  let best = null;
+
+  for (const lessonFile of appliesTo) {
+    const normalizedLessonFile = normalizeFile(lessonFile);
+    if (!normalizedLessonFile) continue;
+    for (const taskFile of files) {
+      const strength = overlapStrength(normalizedLessonFile, taskFile);
+      if (!strength) continue;
+      const score = 300000 + (strength * 10000) + pathSpecificity(normalizedLessonFile) - appliesTo.length;
+      if (!best || score > best.score) {
+        best = { score, why: `file overlaps ${normalizedLessonFile}` };
+      }
+    }
+    if (briefLower.includes(normalizedLessonFile.toLowerCase())) {
+      const score = 200000 + pathSpecificity(normalizedLessonFile) - appliesTo.length;
+      if (!best || score > best.score) {
+        best = { score, why: `brief mentions ${normalizedLessonFile}` };
+      }
+    }
+  }
+
+  const matchedKeywords = slugKeywords(slug).filter((keyword) => keywordAppears(brief, keyword));
+  if (matchedKeywords.length) {
+    const keywordLength = matchedKeywords.reduce((total, keyword) => total + keyword.length, 0);
+    const score = 100000 + (matchedKeywords.length * 1000) + keywordLength;
+    if (!best || score > best.score) {
+      best = { score, why: `brief mentions ${matchedKeywords.join(', ')}` };
+    }
+  }
+
+  return best;
+}
+
+function matchLessons({ briefText = '', files = [], root = process.cwd() } = {}) {
+  const metadata = readJson(path.join(root, 'atris', 'lessons.json'));
+  const lessonText = readLessonText(path.join(root, 'atris', 'lessons.md'));
+  const normalizedFiles = (Array.isArray(files) ? files : [files]).map(normalizeFile).filter(Boolean);
+  const matches = [];
+
+  for (const [slug, lesson] of Object.entries(metadata)) {
+    if (slug === '_schema' || !lesson || typeof lesson !== 'object') continue;
+    if (!lessonIsEligible(lesson)) continue;
+    const text = lessonText.get(slug);
+    if (!text) continue;
+    const matched = bestMatch({ slug, lesson, briefText, files: normalizedFiles });
+    if (!matched) continue;
+    matches.push({ slug, text, why_matched: matched.why, score: matched.score });
+  }
+
+  return matches
+    .sort((left, right) => right.score - left.score || left.slug.localeCompare(right.slug))
+    .slice(0, 5)
+    .map(({ slug, text, why_matched }) => ({ slug, text, why_matched }));
+}
+
+module.exports = { matchLessons };

package/lib/loop-doctor.js

@@ -20,8 +20,6 @@ const HEADLESS_CAPABLE_RUNNERS = new Set([
   'codex',
   'cursor',
   'devin',
-  'hermes',
-  'hermes-agent',
 ]);
 const FINDING_PRIORITY = {
   repeated_auth_failure: 500,

package/lib/mission-human-asks.js

@@ -0,0 +1,28 @@
+'use strict';
+
+function normalizeHumanAsk(ask) {
+  if (typeof ask === 'string') {
+    return { text: ask, answered_at: null };
+  }
+  if (!ask || typeof ask !== 'object' || Array.isArray(ask)) {
+    return { text: String(ask || ''), answered_at: null };
+  }
+  return {
+    ...ask,
+    text: String(ask.text || ''),
+    answered_at: ask.answered_at || null,
+  };
+}
+
+function normalizeHumanAsks(asks) {
+  return Array.isArray(asks) ? asks.map(normalizeHumanAsk) : [];
+}
+
+function openHumanAsks(asks) {
+  return normalizeHumanAsks(asks).filter((ask) => ask.text.trim() && !ask.answered_at);
+}
+
+module.exports = {
+  normalizeHumanAsks,
+  openHumanAsks,
+};

package/lib/mission-protected-lane.js

@@ -127,6 +127,7 @@ function defaultGit(gitBin = 'git') {
     cwd: root,
     encoding: 'utf8',
     timeout: 10000,
+    maxBuffer: 64 * 1024 * 1024,
   });
 }
 
@@ -167,7 +168,8 @@ function protectedPause(reason, detail = {}) {
 }
 
 function unreadableMissionGuard(error) {
-  return protectedPause('mission diff could not be read; human review is required', {
+  return protectedPause('mission diff could not be read; repair the tooling failure and rerun', {
+    status: 'paused-for-retry',
     unreadable: true,
     detail: error?.message || String(error || 'unknown diff read failure'),
     surfaces: ['unreadable diff'],
@@ -285,6 +287,7 @@ function prepareMissionGitGuard({
 }
 
 module.exports = {
+  defaultGit,
   matchProtectedMissionDiff,
   unreadableMissionGuard,
   inspectMissionProtectedDiff,

package/lib/official-cli-integration.js

@@ -67,6 +67,10 @@ function printHelp(config) {
   for (const command of config.commands) {
     console.log(`  ${command.usage.padEnd(13)} ${command.description}`);
   }
+  if (config.commands.some((command) => command.summarize)) {
+    console.log('');
+    console.log('  --raw         print the full cli output instead of the grouped summary');
+  }
   console.log('');
   console.log(`binary: ${config.binary}`);
   console.log(`install: ${config.installHint}`);
@@ -115,14 +119,54 @@ function matchCommand(config, args) {
   });
 }
 
+const SUMMARY_SAMPLE_LINES = 5;
+
+function summaryLines(result) {
+  const stdout = String(result.stdout || '').split(/\r?\n/);
+  const stderr = String(result.stderr || '').split(/\r?\n/);
+  return { stdout, stderr, all: [...stdout, ...stderr].filter((line) => line.trim()) };
+}
+
+function printOutputSummary(config, cliArgs, result) {
+  const status = result.status ?? 0;
+  const { all } = summaryLines(result);
+  const errors = all.filter((line) => /\berror\b|\bfailed\b|\bfatal\b/i.test(line));
+  const warnings = all.filter((line) => /\bwarn/i.test(line));
+  const links = [...new Set(all.flatMap((line) => line.match(/https?:\/\/\S+/g) || []))];
+  const label = `${config.name} ${cliArgs.join(' ')}`.trim();
+
+  console.log(`${label}: ${status === 0 ? 'ok' : `failed (exit ${status})`}, ${all.length} output lines`);
+  console.log('');
+  if (links.length) {
+    console.log(`links (${links.length})`);
+    for (const link of links.slice(0, SUMMARY_SAMPLE_LINES)) console.log(`  ${link}`);
+    console.log('');
+  }
+  console.log(errors.length ? `errors (${errors.length})` : 'errors: none');
+  for (const line of errors.slice(0, SUMMARY_SAMPLE_LINES)) console.log(`  ${line.trim()}`);
+  if (errors.length) console.log('');
+  console.log(warnings.length ? `warnings (${warnings.length})` : 'warnings: none');
+  for (const line of warnings.slice(0, SUMMARY_SAMPLE_LINES)) console.log(`  ${line.trim()}`);
+  if (warnings.length) console.log('');
+  const tail = all.slice(-SUMMARY_SAMPLE_LINES);
+  if (tail.length) {
+    console.log('last lines');
+    for (const line of tail) console.log(`  ${line.trim()}`);
+    console.log('');
+  }
+  console.log(`full output: atris ${label} --raw`);
+}
+
 function runPassthrough(config, command, args) {
   const binary = ensureBinary(config);
   if (!binary.ok) return 1;
 
-  const rest = args.slice(command.match.length);
+  const raw = args.includes('--raw');
+  const rest = args.slice(command.match.length).filter((arg) => arg !== '--raw');
   const cliArgs = [...command.forward, ...rest];
+  const summarize = command.summarize && !raw;
   const result = spawnSync(config.binary, cliArgs, {
-    stdio: 'inherit',
+    ...(summarize ? { encoding: 'utf8' } : { stdio: 'inherit' }),
     env: process.env,
   });
   if (missingBinary(result)) {
@@ -133,6 +177,7 @@ function runPassthrough(config, command, args) {
     console.error(`${config.name} command failed: ${result.error.message}`);
     return 1;
   }
+  if (summarize) printOutputSummary(config, cliArgs, result);
   return result.status ?? 0;
 }
 

package/lib/orb-context.js

@@ -13,7 +13,13 @@ const BACKLOG_STATUSES = new Set(['open', 'backlog', 'inbox', 'planned', 'plan',
 function cleanTitle(value, max = 64) {
   const text = String(value || '').replace(/\s+/g, ' ').trim();
   if (!text) return '';
-  return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+  if (text.length <= max) return text;
+  const slice = text.slice(0, max - 1);
+  const lastSpace = slice.lastIndexOf(' ');
+  // Cut on a word boundary so a title never ends on half a word ("...the owne…").
+  // Fall back to the hard slice only when a single word already fills the limit.
+  const body = lastSpace > 0 ? slice.slice(0, lastSpace) : slice;
+  return `${body.replace(/[\s,;:.!?-]+$/, '')}…`;
 }
 
 function asRecord(value) {
@@ -475,6 +481,7 @@ async function appendOrbChoice(root, label, when = new Date()) {
 }
 
 module.exports = {
+  cleanTitle,
   collectOrbContext,
   appendOrbChoice,
 };