atris 3.35.0 → 3.37.0

package/lib/usage.js

@@ -0,0 +1,107 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { knownCommands } = require('./known-commands');
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+const USAGE_RELATIVE_PATH = path.join('.atris', 'state', 'usage.jsonl');
+const USAGE_MAX_BYTES = 5 * 1024 * 1024;
+
+// Usage telemetry used to write to `<cwd>/.atris/state/usage.jsonl`, so a
+// command run from a subdirectory that already had a nested .atris (e.g.
+// backend/) split its usage away from the workspace root's store — the same
+// footgun the mission and task stores hit. Resolve to the shared workspace
+// root (spine-first -> git toplevel -> cwd) so usage lands with the rest of the
+// state, whichever subdir the caller stood in. Falls back to the raw cwd if the
+// shared resolver can't load; telemetry must never break the command path.
+function resolveUsageRoot(cwd = process.cwd()) {
+  try {
+    const { workspaceRoot } = require('./task-db');
+    const root = workspaceRoot(cwd);
+    if (root) return root;
+  } catch {}
+  return cwd;
+}
+
+function usagePath(cwd = process.cwd()) {
+  return path.join(resolveUsageRoot(cwd), USAGE_RELATIVE_PATH);
+}
+
+function parseUsageLine(line) {
+  try {
+    const entry = JSON.parse(line);
+    if (!entry || typeof entry !== 'object') return null;
+    if (typeof entry.at !== 'string' || typeof entry.cmd !== 'string') return null;
+    return entry;
+  } catch {
+    return null;
+  }
+}
+
+function readAllUsage(cwd = process.cwd()) {
+  const file = usagePath(cwd);
+  try {
+    if (!fs.existsSync(file)) return [];
+  } catch {
+    return [];
+  }
+  const out = [];
+  try {
+    for (const line of fs.readFileSync(file, 'utf8').split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const entry = parseUsageLine(trimmed);
+      if (entry) out.push(entry);
+    }
+  } catch {
+    return [];
+  }
+  return out;
+}
+
+function readUsage(cwd = process.cwd(), options = {}) {
+  const entries = readAllUsage(cwd);
+  const sinceDays = Number(options.sinceDays);
+  if (!Number.isFinite(sinceDays) || sinceDays <= 0) return entries;
+  const now = options.now ? new Date(options.now).getTime() : Date.now();
+  const cutoff = now - sinceDays * DAY_MS;
+  return entries.filter((entry) => {
+    const at = Date.parse(entry.at);
+    return Number.isFinite(at) && at >= cutoff;
+  });
+}
+
+function trimUsageFile(cwd = process.cwd()) {
+  const file = usagePath(cwd);
+  const stat = fs.statSync(file);
+  if (stat.size <= USAGE_MAX_BYTES) return;
+  const cutoff = Date.now() - 30 * DAY_MS;
+  const kept = readAllUsage(cwd).filter((entry) => {
+    const at = Date.parse(entry.at);
+    return Number.isFinite(at) && at >= cutoff;
+  });
+  fs.writeFileSync(file, kept.map((entry) => JSON.stringify(entry)).join('\n') + (kept.length ? '\n' : ''), 'utf8');
+}
+
+function recordUsage(command, cwd = process.cwd()) {
+  try {
+    if (!command || !knownCommands.includes(command)) return;
+    const root = resolveUsageRoot(cwd);
+    // The sensor observes workspaces, it never creates them: recording into a
+    // resolved root with no .atris/ would litter pristine cwds (even `--help`).
+    if (!fs.existsSync(path.join(root, '.atris'))) return;
+    const file = usagePath(root);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.appendFileSync(file, `${JSON.stringify({ at: new Date().toISOString(), cmd: String(command) })}\n`, 'utf8');
+    trimUsageFile(root);
+  } catch {
+    // Usage telemetry must never affect the command path.
+  }
+}
+
+module.exports = {
+  usagePath,
+  recordUsage,
+  readUsage,
+};

package/lib/voice-gate.js

@@ -0,0 +1,163 @@
+'use strict';
+
+const {
+  dejargon,
+  hasAgentJargon,
+  operatorReady,
+  voicePatterns,
+} = require('./autoland');
+
+const EM_DASH = /\u2014/;
+const NUMBER_WORDS = [
+  'no', 'one', 'two', 'three', 'four', 'five', 'six',
+  'seven', 'eight', 'nine', 'ten', 'eleven', 'twelve',
+];
+
+function numberWord(n) {
+  return NUMBER_WORDS[n] || String(n);
+}
+
+function globalPattern(pattern) {
+  const flags = pattern.flags.includes('g') ? pattern.flags : `${pattern.flags}g`;
+  return new RegExp(pattern.source, flags);
+}
+
+function findingsFor(text, pattern, rule, why) {
+  const findings = [];
+  for (const match of String(text || '').matchAll(globalPattern(pattern))) {
+    findings.push({ rule, why, snippet: match[0] });
+  }
+  return findings;
+}
+
+function scanText(text) {
+  const value = String(text || '');
+  const findings = findingsFor(value, EM_DASH, 'em-dash', 'use plain punctuation');
+  if (hasAgentJargon(value)) {
+    findings.push(...findingsFor(
+      value,
+      voicePatterns.agentJargon,
+      'agent-jargon',
+      'replace internal syntax with plain words',
+    ));
+  }
+  findings.push(...findingsFor(
+    value,
+    voicePatterns.rawUlid,
+    'raw-ulid',
+    'name the item instead of showing its database id',
+  ));
+  findings.push(...findingsFor(
+    value,
+    voicePatterns.filePath,
+    'file-path',
+    'describe the proof instead of exposing an internal file location',
+  ));
+  findings.push(...findingsFor(
+    value,
+    voicePatterns.shellCommand,
+    'shell-command',
+    'turn command syntax into a human action',
+  ));
+  return findings;
+}
+
+function cleanEmDashes(text) {
+  return String(text || '')
+    .replace(/\s*\u2014\s*/g, ', ')
+    .replace(/^,\s*/, '')
+    .replace(/,\s*$/, '.')
+    .replace(/([.!?])\s*,\s*/g, '$1 ')
+    .replace(/,\s*([,.;:!?])/g, '$1');
+}
+
+function cleanAfterRemoval(text) {
+  return String(text || '')
+    .replace(/\(\s*\)/g, '')
+    .replace(/\s+([,.;:!?])/g, '$1')
+    .replace(/([:;,])\s*([.!?])/g, '$2')
+    .replace(/\s{2,}/g, ' ')
+    .trim();
+}
+
+function titleCanReplaceId(title) {
+  const value = String(title || '').trim();
+  return Boolean(value) && (operatorReady(value) || !hasAgentJargon(value));
+}
+
+function gateForHuman(text, opts = {}) {
+  let cleaned = cleanEmDashes(text);
+  cleaned = dejargon(cleaned, { preserveTickets: true });
+  if (titleCanReplaceId(opts.title)) {
+    cleaned = cleaned.replace(globalPattern(voicePatterns.rawUlid), '');
+  }
+  cleaned = cleanAfterRemoval(cleaned);
+  const issues = scanText(cleaned);
+  return { ok: issues.length === 0, text: cleaned, issues };
+}
+
+const LANDING_PARTICIPLE_WHY = {
+  avoiding: 'it avoids',
+  cutting: 'it cuts',
+  eliminating: 'it eliminates',
+  giving: 'it gives',
+  keeping: 'it keeps',
+  making: 'it makes',
+  preventing: 'it prevents',
+  reducing: 'it reduces',
+  removing: 'it removes',
+  saving: 'it saves',
+  stopping: 'it stops',
+};
+
+// A landing sentence written for a human already carries its own why
+// ("..., so operators keep deciding instead of waiting"). Split that clause
+// out so "why it matters" quotes the work instead of a canned line; return
+// null when the sentence has no real why.
+function landingWhyClause(sentence) {
+  const text = String(sentence || '').replace(/\s+/g, ' ').trim();
+  const finish = (change, why) => {
+    const cleanChange = String(change || '').replace(/[,;:]+$/, '').trim();
+    const cleanWhy = String(why || '').trim();
+    if (!cleanChange || !cleanWhy) return null;
+    return {
+      change: /[.!?]$/.test(cleanChange) ? cleanChange : `${cleanChange}.`,
+      why: /[.!?]$/.test(cleanWhy) ? cleanWhy : `${cleanWhy}.`,
+    };
+  };
+  const connective = text.match(/^(.{12,}?),?\s+(?:so(?:\s+that)?|because|which means)\s+(.{8,}?)[.!?]?$/i);
+  if (connective) return finish(connective[1], connective[2]);
+  const participles = Object.keys(LANDING_PARTICIPLE_WHY).join('|');
+  const participial = text.match(new RegExp(`^(.{12,}?),\\s+(${participles})\\s+(.{4,}?)[.!?]?$`, 'i'));
+  if (participial) {
+    return finish(participial[1], `${LANDING_PARTICIPLE_WHY[participial[2].toLowerCase()]} ${participial[3]}`);
+  }
+  return null;
+}
+
+// Canned reasons older composers wrote into durable receipts. Treat them as
+// absent so the reader sees the work's own why or nothing at all.
+const RETIRED_FILLER_REASON = new RegExp([
+  '^It makes the result understandable before a human accepts or rejects it\\.$',
+  '^It proves the workflow works in the place people actually use it\\.$',
+  '^It turns the mission into a concrete result a human can accept, reject, or run again\\.$',
+  '^It turns the task title into a concrete result the human can approve\\.$',
+  '^It gives the human a repeatable check before approval\\.$',
+  '^It keeps real-world side effects behind a clear human decision\\.$',
+  '^It keeps private data out of the fast human decision screen\\.$',
+  '^It lets the operator see the next command without hunting\\.$',
+  '^It stops old approvals from running after their context has gone stale\\.$',
+  '^This makes the work easier to judge\\.$',
+].join('|'));
+
+function isRetiredFillerReason(text) {
+  return RETIRED_FILLER_REASON.test(String(text || '').replace(/\s+/g, ' ').trim());
+}
+
+module.exports = {
+  gateForHuman,
+  isRetiredFillerReason,
+  landingWhyClause,
+  numberWord,
+  scanText,
+};