atris 3.34.0 → 3.36.0

package/commands/verify.js

@@ -531,9 +531,105 @@ function verifyRubric(slug, section, opts = {}) {
   }
 }
 
+// Words too common to count as objective coverage signal.
+const OBJECTIVE_STOPWORDS = new Set([
+  'the', 'and', 'for', 'with', 'that', 'this', 'from', 'into', 'each', 'their',
+  'have', 'has', 'are', 'was', 'were', 'will', 'would', 'should', 'could',
+  'about', 'them', 'then', 'than', 'when', 'what', 'where', 'which', 'while',
+  'your', 'yours', 'ours', 'over', 'under', 'after', 'before', 'between',
+  'make', 'made', 'making', 'work', 'working', 'draft', 'write', 'written',
+  'save', 'saved', 'file', 'files', 'become', 'becomes', 'gets', 'also',
+]);
+
+const PLACEHOLDER_LINE_RE = /\b(todo|tbd|fixme|xxx|lorem ipsum|placeholder|fill (?:this|me) in|coming soon)\b/i;
+const HEADING_OR_DIVIDER_RE = /^(#{1,6}\s|[-=*_]{3,}\s*$|\s*[|+][-\s|+]*$)/;
+
+function objectiveKeywords(objective) {
+  const words = String(objective || '').toLowerCase().match(/[a-z][a-z0-9-]{3,}/g) || [];
+  return [...new Set(words.filter((word) => !OBJECTIVE_STOPWORDS.has(word)))];
+}
+
+/**
+ * atris verify artifact <path> - deterministic substance checks for a
+ * mission artifact. This is a pre-filter, not a quality judgment: it kills
+ * empty, skeleton, and placeholder-dominated artifacts that `test -s` lets
+ * through, and (optionally) checks the artifact mentions enough of the
+ * mission objective's vocabulary to plausibly be about it.
+ */
+function verifyArtifact(target, opts = {}) {
+  const cwd = opts.cwd || process.cwd();
+  const minLines = Number.isFinite(opts.minLines) ? opts.minLines : 10;
+  const checks = [];
+  const fail = (name, detail) => checks.push({ name, passed: false, detail });
+  const pass = (name, detail) => checks.push({ name, passed: true, detail });
+
+  const resolved = path.resolve(cwd, String(target || ''));
+  let content = null;
+  try {
+    content = fs.readFileSync(resolved, 'utf8');
+    pass('exists', path.relative(cwd, resolved));
+  } catch {
+    fail('exists', `cannot read ${target}`);
+  }
+
+  if (content !== null) {
+    const lines = content.split('\n');
+    const substantive = lines.filter((line) => line.trim() && !HEADING_OR_DIVIDER_RE.test(line.trim()));
+    if (substantive.length >= minLines) {
+      pass('substance', `${substantive.length} substantive lines (min ${minLines})`);
+    } else {
+      fail('substance', `${substantive.length} substantive lines, need ${minLines}; headings and dividers do not count`);
+    }
+
+    const placeholderLines = substantive.filter((line) => PLACEHOLDER_LINE_RE.test(line));
+    const placeholderShare = substantive.length ? placeholderLines.length / substantive.length : 1;
+    if (placeholderShare <= 0.3) {
+      pass('not_placeholder', `${placeholderLines.length}/${substantive.length} placeholder lines`);
+    } else {
+      fail('not_placeholder', `${placeholderLines.length}/${substantive.length} lines are TODO/TBD/placeholder`);
+    }
+
+    if (opts.objective) {
+      const keywords = objectiveKeywords(opts.objective);
+      const haystack = content.toLowerCase();
+      const hit = keywords.filter((word) => haystack.includes(word));
+      const coverage = keywords.length ? hit.length / keywords.length : 1;
+      if (coverage >= 0.4) {
+        pass('objective_coverage', `${hit.length}/${keywords.length} objective keywords present`);
+      } else {
+        fail('objective_coverage', `only ${hit.length}/${keywords.length} objective keywords present (need 40%): missing ${keywords.filter((w) => !hit.includes(w)).slice(0, 8).join(', ')}`);
+      }
+    }
+
+    if (Number.isFinite(opts.maxAgeHours)) {
+      const ageHours = (Date.now() - fs.statSync(resolved).mtimeMs) / 3600000;
+      if (ageHours <= opts.maxAgeHours) {
+        pass('freshness', `modified ${ageHours.toFixed(1)}h ago (max ${opts.maxAgeHours}h)`);
+      } else {
+        fail('freshness', `modified ${ageHours.toFixed(1)}h ago, older than ${opts.maxAgeHours}h window`);
+      }
+    }
+  }
+
+  const passed = checks.length > 0 && checks.every((check) => check.passed);
+  const result = { ok: passed, artifact: target, checks };
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    for (const check of checks) {
+      console.log(`${check.passed ? '✓' : '✗'} ${check.name}: ${check.detail}`);
+    }
+    console.log(passed
+      ? `artifact passes the substance pre-filter (not a quality judgment)`
+      : `artifact FAILS the substance pre-filter`);
+  }
+  return passed ? 0 : 1;
+}
+
 module.exports = {
   verifyAtris,
   verifyRubric,
+  verifyArtifact,
   findTaskInContent,
   escapeRegExp
 };

package/commands/watch.js

@@ -0,0 +1,303 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { startMission, listMissions } = require('./mission');
+
+const CLI_PATH = path.join(__dirname, '..', 'bin', 'atris.js');
+const VALID_EVERY = new Set(['15m', '1h', '4h']);
+const VALID_NOTIFY = new Set(['journal', 'imessage']);
+const TERMINAL_STATUSES = new Set(['stopped', 'complete']);
+const DEFAULT_EVERY = '1h';
+const DEFAULT_NOTIFY = 'journal';
+const WATCH_OWNER = 'watcher';
+const WATCH_LANE = 'watch';
+
+function slugify(value) {
+  return String(value || 'watch')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 48) || 'watch';
+}
+
+function hasFlag(args, name) {
+  return args.includes(name);
+}
+
+function unquote(value) {
+  const text = String(value);
+  if ((text.startsWith('"') && text.endsWith('"')) || (text.startsWith("'") && text.endsWith("'"))) {
+    return text.slice(1, -1);
+  }
+  return text;
+}
+
+function readFlag(args, name, fallback = '') {
+  const prefix = `${name}=`;
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = String(args[i]);
+    if (arg === name && args[i + 1] && !String(args[i + 1]).startsWith('--')) return unquote(args[i + 1]);
+    if (arg.startsWith(prefix)) return unquote(arg.slice(prefix.length));
+  }
+  return fallback;
+}
+
+function parseSentenceArgs(args) {
+  const sentenceParts = [];
+  let index = 0;
+  while (index < args.length) {
+    const arg = String(args[index]);
+    if (arg.startsWith('--')) break;
+    sentenceParts.push(arg);
+    index += 1;
+  }
+  return {
+    sentence: sentenceParts.join(' ').trim(),
+    rest: args.slice(index),
+  };
+}
+
+function watchStatePath(slug) {
+  return `.atris/state/watch/${slug}.json`;
+}
+
+function buildWatchObjective(sentence, slug) {
+  const statePath = watchStatePath(slug);
+  return `Each tick: check ${sentence}, compare to last tick state under ${statePath}, report only meaningful changes`;
+}
+
+function notifyLabel(notify) {
+  if (notify === 'imessage') return 'imessage when the pulse picks it up';
+  return "today's journal under ## Notes";
+}
+
+function activeWatchMissions(root = process.cwd()) {
+  return listMissions(root).filter((mission) => (
+    mission.lane === WATCH_LANE && !TERMINAL_STATUSES.has(mission.status)
+  ));
+}
+
+function watchName(mission) {
+  return mission.metadata?.watch_slug || mission.slug || mission.id;
+}
+
+function resolveWatchMission(ref, root = process.cwd()) {
+  const slug = slugify(ref);
+  return activeWatchMissions(root).find((mission) => (
+    watchName(mission) === slug || mission.slug === slug || mission.id === ref
+  )) || null;
+}
+
+function formatLastTick(mission) {
+  if (!mission.last_tick_at) return 'never';
+  const ageMs = Date.now() - Date.parse(mission.last_tick_at);
+  if (!Number.isFinite(ageMs) || ageMs < 0) return mission.last_tick_at;
+  const minutes = Math.floor(ageMs / 60000);
+  if (minutes < 1) return 'just now';
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 48) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+
+function formatLastReport(mission) {
+  const line = String(mission.last_tick_reason || mission.metadata?.last_report || '').trim();
+  return line || 'none yet';
+}
+
+function padCell(value, width) {
+  const text = String(value);
+  if (text.length <= width) return text.padEnd(width);
+  if (width <= 1) return text.slice(0, width);
+  return `${text.slice(0, width - 1)}…`;
+}
+
+function printWatchTable(missions) {
+  const rows = missions.map((mission) => ({
+    name: watchName(mission),
+    cadence: mission.cadence || DEFAULT_EVERY,
+    lastTick: formatLastTick(mission),
+    lastReport: formatLastReport(mission),
+  }));
+  const widths = {
+    name: Math.max(4, ...rows.map((row) => row.name.length)),
+    cadence: Math.max(7, ...rows.map((row) => row.cadence.length)),
+    lastTick: Math.max(9, ...rows.map((row) => row.lastTick.length)),
+    lastReport: Math.max(11, ...rows.map((row) => row.lastReport.length)),
+  };
+  console.log([
+    padCell('name', widths.name),
+    padCell('cadence', widths.cadence),
+    padCell('last tick', widths.lastTick),
+    padCell('last report', widths.lastReport),
+  ].join('  '));
+  for (const row of rows) {
+    console.log([
+      padCell(row.name, widths.name),
+      padCell(row.cadence, widths.cadence),
+      padCell(row.lastTick, widths.lastTick),
+      padCell(row.lastReport, widths.lastReport),
+    ].join('  '));
+  }
+}
+
+function showWatchHelp() {
+  console.log('');
+  console.log('usage: atris watch "<sentence>" [--every 15m|1h|4h] [--name <slug>] [--notify imessage|journal]');
+  console.log('       atris watch list');
+  console.log('       atris watch stop <slug>');
+  console.log('');
+  console.log('turn one sentence into an always-on claude watch mission.');
+  console.log('');
+  console.log('options:');
+  console.log('  --every cadence   how often to check (default 1h)');
+  console.log('  --name slug       stable watch name (default derived from the sentence)');
+  console.log('  --notify channel  journal (default) or imessage preference for the pulse');
+  console.log('');
+  console.log('looking for the old file-sync watcher? use: atris sync --watch');
+  console.log('');
+}
+
+function createWatch(args, cwd = process.cwd()) {
+  const { sentence, rest } = parseSentenceArgs(args);
+  if (!sentence) {
+    console.error('usage: atris watch "<sentence>" [--every 15m|1h|4h] [--name <slug>] [--notify imessage|journal]');
+    return 2;
+  }
+
+  const slug = slugify(readFlag(rest, '--name', '') || sentence);
+  const every = readFlag(rest, '--every', DEFAULT_EVERY) || DEFAULT_EVERY;
+  const notify = readFlag(rest, '--notify', DEFAULT_NOTIFY) || DEFAULT_NOTIFY;
+
+  if (!VALID_EVERY.has(every)) {
+    console.error(`--every must be one of: ${Array.from(VALID_EVERY).join(', ')}`);
+    return 2;
+  }
+  if (!VALID_NOTIFY.has(notify)) {
+    console.error(`--notify must be one of: ${Array.from(VALID_NOTIFY).join(', ')}`);
+    return 2;
+  }
+
+  const stateRel = watchStatePath(slug);
+  fs.mkdirSync(path.join(cwd, path.dirname(stateRel)), { recursive: true });
+
+  const objective = buildWatchObjective(sentence, slug);
+  const startArgs = [
+    objective,
+    '--owner', WATCH_OWNER,
+    '--lane', WATCH_LANE,
+    '--runner', 'claude',
+    '--cadence', every,
+    '--always-on',
+    '--no-verify',
+    '--stop', 'owner stops the watch',
+  ];
+
+  const previousCwd = process.cwd();
+  process.chdir(cwd);
+  try {
+    startMission(startArgs, {
+      silent: true,
+      missionPatch: {
+        slug,
+        metadata: {
+          watch: true,
+          watch_slug: slug,
+          watch_sentence: sentence,
+          watch_state_path: stateRel,
+          notify,
+        },
+      },
+    });
+  } finally {
+    process.chdir(previousCwd);
+  }
+
+  console.log(`watching ${sentence} every ${every}.`);
+  console.log(`reports land in ${notifyLabel(notify)}.`);
+  console.log(`state file: ${stateRel}`);
+  console.log(`stop with: atris watch stop ${slug}`);
+  return 0;
+}
+
+function listWatch(cwd = process.cwd()) {
+  const missions = activeWatchMissions(cwd);
+  if (!missions.length) {
+    console.log('no active watches.');
+    return 0;
+  }
+  printWatchTable(missions);
+  return 0;
+}
+
+function stopWatch(ref, cwd = process.cwd()) {
+  const slug = slugify(ref);
+  if (!slug) {
+    console.error('usage: atris watch stop <slug>');
+    return 2;
+  }
+  const mission = resolveWatchMission(slug, cwd);
+  if (!mission) {
+    console.error(`no active watch named "${slug}".`);
+    return 1;
+  }
+
+  const result = spawnSync(process.execPath, [
+    CLI_PATH,
+    'mission',
+    'stop',
+    mission.id,
+    '--reason',
+    'owner stops the watch',
+    '--json',
+  ], {
+    cwd,
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      ATRIS_SKIP_UPDATE_CHECK: '1',
+    },
+  });
+
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    const message = String(result.stderr || result.stdout || '').trim();
+    console.error(message || `failed to stop watch "${slug}".`);
+    return result.status || 1;
+  }
+
+  console.log(`stopped watch ${slug}.`);
+  return 0;
+}
+
+function watchCommand(args = [], cwd = process.cwd()) {
+  if (hasFlag(args, '--help') || hasFlag(args, '-h') || args[0] === 'help') {
+    showWatchHelp();
+    return 0;
+  }
+
+  const subcommand = String(args[0] || '').trim().toLowerCase();
+  if (subcommand === 'list') return listWatch(cwd);
+  if (subcommand === 'stop') return stopWatch(args[1], cwd);
+
+  return createWatch(args, cwd);
+}
+
+function watchAtris() {
+  const code = watchCommand(process.argv.slice(3), process.cwd());
+  process.exit(code);
+}
+
+module.exports = {
+  watchAtris,
+  watchCommand,
+  showWatchHelp,
+  slugify,
+  buildWatchObjective,
+  activeWatchMissions,
+  resolveWatchMission,
+  watchStatePath,
+};