atris 3.47.0 → 3.48.0

package/scripts/det/date.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+// det/date.js — deterministic date/time conversion. Epoch<->ISO and weekday are
+// the asks LLMs fumble most (seconds vs ms, and timezone guesses). Everything is
+// UTC so the answer is the same on every machine. Reads stdin, writes stdout.
+//
+// Usage:
+//   echo 1700000000    | node date.js iso       # epoch (s or ms) -> ISO 8601 UTC
+//   echo 2026-07-07    | node date.js epoch      # date/ISO -> epoch seconds
+//   echo 2026-07-07    | node date.js epochms    # -> epoch milliseconds
+//   echo 2026-07-07    | node date.js weekday    # -> Monday..Sunday (UTC)
+//
+// Modes: iso | epoch | epochms | weekday
+// Bare date strings (no timezone) are read as UTC. Exit 2 on bad mode/input.
+
+'use strict';
+
+const DAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+
+// Parse stdin into a Date, deterministically. A pure-digit string is an epoch
+// (>=13 digits = ms, else seconds). Otherwise a date string; if it carries no
+// timezone we pin it to UTC by appending 'Z' so machines don't disagree.
+function toDate(s) {
+  const t = s.trim();
+  if (t === '') return { error: 'empty input' };
+  if (/^-?\d+$/.test(t)) {
+    const n = Number(t);
+    const ms = t.replace('-', '').length >= 13 ? n : n * 1000;
+    return { date: new Date(ms) };
+  }
+  // ISO-ish without an explicit zone/offset -> treat as UTC.
+  let str = t;
+  const hasZone = /[zZ]$|[+-]\d{2}:?\d{2}$/.test(t);
+  if (!hasZone) {
+    str = /\d{4}-\d{2}-\d{2}$/.test(t) ? t + 'T00:00:00Z' : t + 'Z';
+  }
+  const d = new Date(str);
+  if (Number.isNaN(d.getTime())) return { error: `cannot parse date: ${t}` };
+  return { date: d };
+}
+
+// Pure core: returns { text } or { error }.
+function run(mode, input) {
+  const p = toDate(input);
+  if (p.error) return { error: p.error };
+  const d = p.date;
+  switch (mode) {
+    case 'iso':
+      return { text: d.toISOString() };
+    case 'epoch':
+      return { text: String(Math.floor(d.getTime() / 1000)) };
+    case 'epochms':
+      return { text: String(d.getTime()) };
+    case 'weekday':
+      return { text: DAYS[d.getUTCDay()] };
+    default:
+      return { error: `unknown mode: ${mode}` };
+  }
+}
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (c) => (data += c));
+    process.stdin.on('end', () => resolve(data));
+    if (process.stdin.isTTY) resolve('');
+  });
+}
+
+const MODES = ['iso', 'epoch', 'epochms', 'weekday'];
+
+async function main() {
+  const mode = process.argv.slice(2).find((a) => !a.startsWith('-'));
+  if (!mode || !MODES.includes(mode)) {
+    process.stderr.write(`unknown mode: ${mode || '(none)'}\nmodes: ${MODES.join(' | ')}\n`);
+    process.exit(2);
+  }
+  const input = await readStdin();
+  const res = run(mode, input);
+  if (res.error) {
+    process.stderr.write(res.error + '\n');
+    process.exit(2);
+  }
+  if (res.text.length) process.stdout.write(res.text + '\n');
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { run, toDate, MODES };

package/scripts/det/det.js

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+// det/det.js — one entrypoint for the deterministic task scripts. A cheap model
+// runs `node det.js` to see the whole catalog, then `node det.js <script> <mode>`
+// to route its stdin through the right one. No need to know the file layout.
+//
+//   node det.js                      # print the catalog (task -> script -> modes)
+//   node det.js --json               # same, machine-readable
+//   node det.js extract urls < f     # route stdin through extract.js in urls mode
+//   node det.js json csv < arr.json  # route stdin through json.js in csv mode
+//
+// The catalog is derived from the scripts themselves (their exported MODES /
+// EXTRACTORS), so it can never drift from what actually runs.
+
+'use strict';
+
+const extract = require('./extract');
+const json = require('./json');
+const text = require('./text');
+const hash = require('./hash');
+const date = require('./date');
+const voice = require('./voice');
+
+// git-facing scripts: they read the repo, not stdin, so they aren't routable
+// through det.js. Listed here only so the front door surfaces all the tools —
+// a cheap model running `det.js` sees these too and knows to run them directly.
+const GIT_SCRIPTS = [
+  {
+    name: 'commit-msg',
+    ask: 'draft a Conventional-Commits message from the staged diff',
+    usage: 'git add -A && node scripts/det/commit-msg.js',
+  },
+  {
+    name: 'changelog',
+    ask: 'group commits since a ref/tag into a changelog',
+    usage: 'node scripts/det/changelog.js [ref]',
+  },
+  {
+    name: 'pr-description',
+    ask: 'draft a PR title + area summary + test-plan from the branch diff',
+    usage: 'node scripts/det/pr-description.js [base]',
+  },
+];
+
+// script -> { ask, modes, run(mode, input) -> {text}|{error} }
+const CATALOG = {
+  extract: {
+    ask: 'pull links / emails / code / numbers out of text',
+    modes: Object.keys(extract.EXTRACTORS),
+    run: (mode, input) => {
+      const items = extract.extract(mode, input);
+      return items === null ? { error: `unknown mode: ${mode}` } : { text: items.join('\n') };
+    },
+  },
+  json: {
+    ask: 'reformat / validate / flatten JSON (incl. JSON->CSV)',
+    modes: json.MODES,
+    run: json.run,
+  },
+  text: {
+    ask: 'dedupe / sort / count / slugify / trim lines',
+    modes: text.MODES,
+    run: text.run,
+  },
+  hash: {
+    ask: 'base64 / hex encode-decode, sha256 / sha1 / md5',
+    modes: hash.MODES,
+    run: hash.run,
+  },
+  date: {
+    ask: 'epoch <-> ISO, weekday (all UTC)',
+    modes: date.MODES,
+    run: date.run,
+  },
+  voice: {
+    ask: 'score a chat reply against the way of talking (PASS or findings)',
+    modes: voice.MODES,
+    run: voice.run,
+  },
+};
+
+function catalogText() {
+  const rows = Object.entries(CATALOG).map(
+    ([name, s]) => `  ${name.padEnd(9)} ${s.modes.join(' ')}\n    ${s.ask}`
+  );
+  const gitRows = GIT_SCRIPTS.map((g) => `  ${g.name.padEnd(15)} ${g.usage}\n    ${g.ask}`);
+  return (
+    'deterministic task scripts — run: node det.js <script> <mode> < input\n\n' +
+    rows.join('\n\n') +
+    '\n\ngit-facing (read the repo, run the script directly; not via det.js):\n\n' +
+    gitRows.join('\n\n') +
+    '\n'
+  );
+}
+
+function catalogJson() {
+  const out = {};
+  for (const [name, s] of Object.entries(CATALOG)) out[name] = { ask: s.ask, modes: s.modes };
+  const git = {};
+  for (const g of GIT_SCRIPTS) git[g.name] = { ask: g.ask, usage: g.usage };
+  return JSON.stringify({ ...out, git }, null, 2);
+}
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (c) => (data += c));
+    process.stdin.on('end', () => resolve(data));
+    if (process.stdin.isTTY) resolve('');
+  });
+}
+
+async function main() {
+  const args = process.argv.slice(2).filter((a) => a !== '--json');
+  const wantJson = process.argv.includes('--json');
+  const [script, mode] = args;
+
+  if (!script) {
+    process.stdout.write((wantJson ? catalogJson() : catalogText()) + '\n');
+    return;
+  }
+  const git = GIT_SCRIPTS.find((g) => g.name === script);
+  if (git) {
+    process.stdout.write(`${git.name} reads the repo, not stdin — run it directly:\n  ${git.usage}\n`);
+    return;
+  }
+  const entry = CATALOG[script];
+  if (!entry) {
+    process.stderr.write(`unknown script: ${script}\nscripts: ${Object.keys(CATALOG).join(' | ')}\n`);
+    process.exit(2);
+  }
+  if (!mode || !entry.modes.includes(mode)) {
+    process.stderr.write(`unknown mode: ${mode || '(none)'}\nmodes: ${entry.modes.join(' | ')}\n`);
+    process.exit(2);
+  }
+  const input = await readStdin();
+  const res = entry.run(mode, input);
+  if (res.error) {
+    process.stderr.write(res.error + '\n');
+    process.exit(2);
+  }
+  if (res.text.length) process.stdout.write(res.text + '\n');
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { CATALOG, catalogJson, catalogText, GIT_SCRIPTS };

package/scripts/det/extract.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+// det/extract.js — deterministically pull structured items out of text.
+// Replaces the "extract all the X from this" ask that a cheap LLM does slowly
+// and sometimes wrong. Reads stdin, writes one item per line to stdout.
+//
+// Usage:
+//   cat file.txt | node extract.js urls
+//   node extract.js emails < file.txt
+//   node extract.js code < README.md        # fenced ```code blocks
+//   node extract.js numbers < report.txt
+//   node extract.js --json urls < file.txt   # JSON array instead of lines
+//
+// Kinds: urls | emails | code | numbers | ipv4 | hashtags
+// Exit 0 with output, exit 2 on bad/unknown kind. Duplicates removed, order preserved.
+
+'use strict';
+
+const EXTRACTORS = {
+  urls: (t) => match(t, /\bhttps?:\/\/[^\s<>"')\]]+/g).map(stripTrailingPunct),
+  emails: (t) => match(t, /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g),
+  ipv4: (t) => match(t, /\b(?:(?:25[0-5]|2[0-4]\d|1?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|1?\d?\d)\b/g),
+  hashtags: (t) => match(t, /(?:^|\s)(#[A-Za-z0-9_]+)/g).map((m) => m.trim()),
+  numbers: (t) => match(t, /-?\b\d[\d,]*(?:\.\d+)?\b/g),
+  code: (t) => {
+    // Fenced blocks: ```lang\n...\n```  — return block contents (not fences).
+    const blocks = [];
+    const re = /```[^\n]*\n([\s\S]*?)```/g;
+    let m;
+    while ((m = re.exec(t)) !== null) blocks.push(m[1].replace(/\n$/, ''));
+    return blocks;
+  },
+};
+
+function match(text, re) {
+  return text.match(re) || [];
+}
+
+function stripTrailingPunct(s) {
+  return s.replace(/[.,;:!?]+$/, '');
+}
+
+function dedupePreserveOrder(items) {
+  const seen = new Set();
+  const out = [];
+  for (const it of items) {
+    if (!seen.has(it)) {
+      seen.add(it);
+      out.push(it);
+    }
+  }
+  return out;
+}
+
+function extract(kind, text) {
+  const fn = EXTRACTORS[kind];
+  if (!fn) return null;
+  return dedupePreserveOrder(fn(text));
+}
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (c) => (data += c));
+    process.stdin.on('end', () => resolve(data));
+    if (process.stdin.isTTY) resolve('');
+  });
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const json = args.includes('--json');
+  const kind = args.find((a) => !a.startsWith('-'));
+  if (!kind || !EXTRACTORS[kind]) {
+    process.stderr.write(
+      `unknown kind: ${kind || '(none)'}\nkinds: ${Object.keys(EXTRACTORS).join(' | ')}\n`
+    );
+    process.exit(2);
+  }
+  const text = await readStdin();
+  const items = extract(kind, text);
+  if (json) {
+    process.stdout.write(JSON.stringify(items) + '\n');
+  } else if (items.length) {
+    process.stdout.write(items.join('\n') + '\n');
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { extract, EXTRACTORS };

package/scripts/det/hash.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+// det/hash.js — deterministic encode / hash. The "base64 this" and "give me the
+// sha256" asks an LLM fakes or does wrong. Reads stdin, writes stdout.
+//
+// Usage:
+//   printf 'hi' | node hash.js b64          # base64 encode
+//   node hash.js b64d   < encoded.txt        # base64 decode
+//   node hash.js sha256 < file.txt           # hex sha256 of the bytes
+//   node hash.js sha1   < file.txt
+//   node hash.js md5    < file.txt
+//   node hash.js hexenc < file.txt           # raw -> hex
+//   node hash.js hexdec < hex.txt            # hex -> raw
+//
+// Modes: b64 | b64d | sha256 | sha1 | md5 | hexenc | hexdec
+// Input's trailing newline is stripped before encoding/hashing so
+// `printf 'hi'` and `echo hi` give the same result. Exit 2 on bad mode/input.
+
+'use strict';
+
+const crypto = require('crypto');
+
+const DIGESTS = { sha256: 'sha256', sha1: 'sha1', md5: 'md5' };
+
+// Pure core: returns { text } or { error }. Unit-testable.
+function run(mode, input) {
+  // Strip a single trailing newline so shell echo vs printf agree.
+  const raw = input.replace(/\n$/, '');
+  if (DIGESTS[mode]) {
+    return { text: crypto.createHash(DIGESTS[mode]).update(raw, 'utf8').digest('hex') };
+  }
+  switch (mode) {
+    case 'b64':
+      return { text: Buffer.from(raw, 'utf8').toString('base64') };
+    case 'b64d':
+      return { text: Buffer.from(raw, 'base64').toString('utf8') };
+    case 'hexenc':
+      return { text: Buffer.from(raw, 'utf8').toString('hex') };
+    case 'hexdec':
+      if (!/^[0-9a-fA-F]*$/.test(raw) || raw.length % 2 !== 0) {
+        return { error: 'hexdec needs an even-length hex string' };
+      }
+      return { text: Buffer.from(raw, 'hex').toString('utf8') };
+    default:
+      return { error: `unknown mode: ${mode}` };
+  }
+}
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (c) => (data += c));
+    process.stdin.on('end', () => resolve(data));
+    if (process.stdin.isTTY) resolve('');
+  });
+}
+
+const MODES = ['b64', 'b64d', 'sha256', 'sha1', 'md5', 'hexenc', 'hexdec'];
+
+async function main() {
+  const mode = process.argv.slice(2).find((a) => !a.startsWith('-'));
+  if (!mode || !MODES.includes(mode)) {
+    process.stderr.write(`unknown mode: ${mode || '(none)'}\nmodes: ${MODES.join(' | ')}\n`);
+    process.exit(2);
+  }
+  const input = await readStdin();
+  const res = run(mode, input);
+  if (res.error) {
+    process.stderr.write(res.error + '\n');
+    process.exit(2);
+  }
+  if (res.text.length) process.stdout.write(res.text + '\n');
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { run, MODES };

package/scripts/det/hunk-filter.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+// det/hunk-filter.js - keep only unified-diff hunks whose lines match a regex.
+// For concurrent-editor workspaces: stage YOUR hunk of a shared file without
+// sweeping in other agents' churn (git apply --cached the filtered patch).
+//
+// Usage:
+//   git diff -U1 -- path/file | node scripts/det/hunk-filter.js "<regex>"
+//   git diff -U1 -- path/file | node scripts/det/hunk-filter.js "Horizon" | git apply --cached --unidiff-zero -
+//
+// A file section is printed only when at least one of its hunks matches.
+// Exit 0 on success (even if nothing matched), 2 on missing pattern.
+'use strict';
+
+function filterHunks(diffText, pattern) {
+  const re = new RegExp(pattern);
+  const lines = String(diffText).split('\n');
+  const out = [];
+  let header = [];
+  let hunk = null;
+  let fileHasMatch = false;
+  let fileHunks = [];
+
+  const flushFile = () => {
+    if (fileHasMatch && fileHunks.length) {
+      out.push(...header, ...fileHunks);
+    }
+    header = [];
+    fileHunks = [];
+    fileHasMatch = false;
+  };
+  const flushHunk = () => {
+    if (!hunk) return;
+    if (hunk.some((l) => re.test(l))) {
+      fileHunks.push(...hunk);
+      fileHasMatch = true;
+    }
+    hunk = null;
+  };
+
+  for (const line of lines) {
+    if (line.startsWith('diff --git ')) {
+      flushHunk();
+      flushFile();
+      header = [line];
+    } else if (line.startsWith('@@')) {
+      flushHunk();
+      hunk = [line];
+    } else if (hunk) {
+      hunk.push(line);
+    } else {
+      header.push(line);
+    }
+  }
+  flushHunk();
+  flushFile();
+  const text = out.join('\n');
+  return text && !text.endsWith('\n') ? `${text}\n` : text;
+}
+
+module.exports = { filterHunks };
+
+if (require.main === module) {
+  const pattern = process.argv[2];
+  if (!pattern) {
+    console.error('usage: git diff -U1 -- file | hunk-filter.js "<regex>"');
+    process.exit(2);
+  }
+  let input = '';
+  process.stdin.on('data', (c) => { input += c; });
+  process.stdin.on('end', () => {
+    process.stdout.write(filterHunks(input, pattern));
+  });
+}

package/scripts/det/json.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+// det/json.js — deterministic JSON reshaping. The reformat/validate/flatten asks
+// an LLM does by hand (and mis-escapes). Reads JSON on stdin, writes stdout.
+//
+// Usage:
+//   cat data.json | node json.js pretty          # 2-space indent
+//   node json.js min      < data.json             # minified, one line
+//   node json.js validate < data.json             # prints "valid" or errors (exit 2)
+//   node json.js keys     < data.json             # top-level keys, one per line
+//   node json.js csv      < array.json            # array of objects -> RFC-4180 CSV
+//
+// Modes: pretty | min | validate | keys | csv
+// Exit 0 on success, 2 on invalid JSON or bad mode/shape.
+
+'use strict';
+
+function parse(text) {
+  try {
+    return { ok: true, value: JSON.parse(text) };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+// RFC-4180: quote a field if it holds comma, quote, CR or LF; double inner quotes.
+function csvField(v) {
+  let s;
+  if (v === null || v === undefined) s = '';
+  else if (typeof v === 'object') s = JSON.stringify(v);
+  else s = String(v);
+  if (/[",\r\n]/.test(s)) s = '"' + s.replace(/"/g, '""') + '"';
+  return s;
+}
+
+function toCsv(arr) {
+  if (!Array.isArray(arr)) throw new Error('csv mode needs a JSON array of objects');
+  if (arr.length === 0) return '';
+  // Column order = first-seen key order across all rows (stable, deterministic).
+  const cols = [];
+  const seen = new Set();
+  for (const row of arr) {
+    if (row === null || typeof row !== 'object' || Array.isArray(row)) {
+      throw new Error('csv mode needs each item to be an object');
+    }
+    for (const k of Object.keys(row)) {
+      if (!seen.has(k)) {
+        seen.add(k);
+        cols.push(k);
+      }
+    }
+  }
+  const lines = [cols.map(csvField).join(',')];
+  for (const row of arr) {
+    lines.push(cols.map((c) => csvField(row[c])).join(','));
+  }
+  return lines.join('\n');
+}
+
+// Returns { text } on success or { error } on failure. Pure — unit-testable.
+function run(mode, input) {
+  if (mode === 'validate') {
+    const p = parse(input);
+    return p.ok ? { text: 'valid' } : { error: p.error };
+  }
+  const p = parse(input);
+  if (!p.ok) return { error: p.error };
+  const v = p.value;
+  switch (mode) {
+    case 'pretty':
+      return { text: JSON.stringify(v, null, 2) };
+    case 'min':
+      return { text: JSON.stringify(v) };
+    case 'keys':
+      if (v === null || typeof v !== 'object' || Array.isArray(v)) {
+        return { error: 'keys mode needs a JSON object' };
+      }
+      return { text: Object.keys(v).join('\n') };
+    case 'csv':
+      try {
+        return { text: toCsv(v) };
+      } catch (e) {
+        return { error: e.message };
+      }
+    default:
+      return { error: `unknown mode: ${mode}` };
+  }
+}
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (c) => (data += c));
+    process.stdin.on('end', () => resolve(data));
+    if (process.stdin.isTTY) resolve('');
+  });
+}
+
+const MODES = ['pretty', 'min', 'validate', 'keys', 'csv'];
+
+async function main() {
+  const mode = process.argv.slice(2).find((a) => !a.startsWith('-'));
+  if (!mode || !MODES.includes(mode)) {
+    process.stderr.write(`unknown mode: ${mode || '(none)'}\nmodes: ${MODES.join(' | ')}\n`);
+    process.exit(2);
+  }
+  const input = await readStdin();
+  const res = run(mode, input);
+  if (res.error) {
+    process.stderr.write(res.error + '\n');
+    process.exit(2);
+  }
+  if (res.text.length) process.stdout.write(res.text + '\n');
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { run, toCsv, MODES };