atris 3.15.13 → 3.15.22

package/commands/integrations.js

@@ -418,6 +418,520 @@ function imessageRecent(handle, options = {}) {
   console.log(result.stdout.trim() || 'No recent messages found.');
 }
 
+function escapeSqlString(value) {
+  return String(value || '').replace(/'/g, "''");
+}
+
+function normalizeLookupKey(value) {
+  return String(value || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9@+]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function normalizeImessageHandle(value) {
+  const raw = String(value || '').trim();
+  if (!raw) return '';
+  if (raw.includes('@')) return raw;
+  const digits = raw.replace(/[^\d]/g, '');
+  if (digits.length === 10) return `+1${digits}`;
+  if (digits.length === 11 && digits.startsWith('1')) return `+${digits}`;
+  return raw;
+}
+
+function normalizeContactLabel(value) {
+  return String(value || '')
+    .replace(/^_\$!<|>!\$_$/g, '')
+    .replace(/^\$!<|>!\$$/g, '')
+    .trim() || 'other';
+}
+
+function imessageLookupCachePath() {
+  return path.join(os.homedir(), '.atris', 'cache', 'imessage-contacts.json');
+}
+
+function readImessageLookupCache() {
+  const cachePath = imessageLookupCachePath();
+  try {
+    return JSON.parse(fs.readFileSync(cachePath, 'utf8'));
+  } catch {
+    return { version: 1, entries: {} };
+  }
+}
+
+function writeImessageLookupCache(cache) {
+  const cachePath = imessageLookupCachePath();
+  fs.mkdirSync(path.dirname(cachePath), { recursive: true });
+  fs.writeFileSync(cachePath, JSON.stringify(cache, null, 2), 'utf8');
+  return cachePath;
+}
+
+function sleepMs(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+function readLatestOutgoingImessage(handle, sinceMs) {
+  const chatDb = path.join(os.homedir(), 'Library', 'Messages', 'chat.db');
+  const sinceUnix = Math.max(0, Math.floor(Number(sinceMs || Date.now()) / 1000) - 5);
+  const sql = `
+    SELECT m.rowid,
+           datetime(m.date/1000000000 + 978307200, 'unixepoch', 'localtime') AS ts,
+           m.is_sent,
+           m.is_delivered,
+           m.is_finished,
+           COALESCE(m.error, 0) AS error,
+           length(COALESCE(m.text,'')) AS text_len
+    FROM message m
+    JOIN handle h ON h.rowid = m.handle_id
+    WHERE h.id = '${escapeSqlString(handle)}'
+      AND m.is_from_me = 1
+      AND (m.date/1000000000 + 978307200) >= ${sinceUnix}
+    ORDER BY m.date DESC
+    LIMIT 1;
+  `;
+  const result = spawnSync('sqlite3', ['-readonly', chatDb, sql], { encoding: 'utf8' });
+  if (result.status !== 0) {
+    return {
+      matched: false,
+      error: (result.stderr || 'Failed to verify latest outgoing iMessage.').trim(),
+    };
+  }
+  const row = String(result.stdout || '').trim();
+  if (!row) {
+    return {
+      matched: false,
+      error: 'No outgoing Messages row found after send.',
+    };
+  }
+  const [rowid, ts, isSent, isDelivered, isFinished, messageError, textLen] = row.split('|');
+  return {
+    matched: true,
+    rowid,
+    timestamp: ts,
+    is_sent: Number(isSent) === 1,
+    is_delivered: Number(isDelivered) === 1,
+    is_finished: Number(isFinished) === 1,
+    message_error: Number(messageError) || 0,
+    text_readable: Number(textLen) > 0,
+  };
+}
+
+function imessageVerifyLatestOutgoing(handle, sinceMs, options = {}) {
+  const timeoutMs = Math.max(0, Number(options.timeoutMs || 2000));
+  const intervalMs = Math.max(25, Number(options.intervalMs || 150));
+  const startedAt = Date.now();
+  let latest = readLatestOutgoingImessage(handle, sinceMs);
+  while (
+    latest.matched
+    && latest.message_error === 0
+    && !(latest.is_sent || latest.is_delivered || latest.is_finished)
+    && Date.now() - startedAt < timeoutMs
+  ) {
+    sleepMs(intervalMs);
+    latest = readLatestOutgoingImessage(handle, sinceMs);
+  }
+  return {
+    ...latest,
+    settled: Boolean(latest.matched && latest.message_error === 0 && (latest.is_sent || latest.is_delivered || latest.is_finished)),
+    waited_ms: Date.now() - startedAt,
+  };
+}
+
+function parseImessageLookupArgs(args) {
+  const options = {
+    json: false,
+    refresh: false,
+    name: '',
+    maxAgeMs: 7 * 24 * 60 * 60 * 1000,
+  };
+  const positional = [];
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === '--json') {
+      options.json = true;
+    } else if (arg === '--refresh') {
+      options.refresh = true;
+    } else if (arg === '--name' || arg === '--query') {
+      options.name = args[i + 1] || '';
+      i += 1;
+    } else if (arg === '--max-age-minutes') {
+      options.maxAgeMs = Math.max(0, Number(args[i + 1] || 0) * 60 * 1000);
+      i += 1;
+    } else {
+      positional.push(arg);
+    }
+  }
+  if (!options.name && positional.length) options.name = positional.join(' ');
+  options.name = String(options.name || '').trim();
+  return options;
+}
+
+const CONTACT_LOOKUP_SCRIPT = `
+function run(argv) {
+  const query = String(argv[0] || '').trim();
+  const Contacts = Application('Contacts');
+  const selfAlias = /^(me|myself|self|my number|my phone|my contact)$/i.test(query);
+  function safe(fn) {
+    try {
+      const value = fn();
+      return value === null || value === undefined ? '' : String(value);
+    } catch (error) {
+      return '';
+    }
+  }
+  function propertyRows(rows) {
+    const out = [];
+    try {
+      const list = rows();
+      for (let i = 0; i < list.length; i += 1) {
+        const item = list[i];
+        out.push({
+          label: safe(function () { return item.label(); }),
+          value: safe(function () { return item.value(); })
+        });
+      }
+    } catch (error) {}
+    return out.filter(function (row) { return row.value; });
+  }
+  function contactRow(person) {
+    return {
+      id: safe(function () { return person.id(); }),
+      name: safe(function () { return person.name(); }),
+      first_name: safe(function () { return person.firstName(); }),
+      last_name: safe(function () { return person.lastName(); }),
+      organization: safe(function () { return person.organization(); }),
+      phones: propertyRows(function () { return person.phones(); }),
+      emails: propertyRows(function () { return person.emails(); })
+    };
+  }
+  let people = [];
+  if (selfAlias) {
+    if (Contacts.myCard.exists()) people = [Contacts.myCard];
+  } else {
+    people = Contacts.people.whose({ name: { _contains: query } })();
+    if (!people.length && query.indexOf(' ') > -1) {
+      people = Contacts.people.whose({ name: { _contains: query.split(/\\s+/)[0] } })();
+    }
+  }
+  const rows = [];
+  const limit = Math.min(20, people.length);
+  for (let i = 0; i < limit; i += 1) rows.push(contactRow(people[i]));
+  return JSON.stringify({ ok: true, query: query, self_alias: selfAlias, contacts_count: people.length, matches: rows });
+}
+`;
+
+function scoreImessageContact(query, match, selfAlias = false) {
+  if (selfAlias) return 100;
+  const q = normalizeLookupKey(query);
+  const name = normalizeLookupKey(match.name);
+  if (!q || !name) return 0;
+  if (name === q) return 95;
+  if (name.includes(q)) return 80;
+  const tokens = q.split(' ').filter(Boolean);
+  const nameTokens = new Set(name.split(' ').filter(Boolean));
+  if (tokens.length && tokens.every((token) => nameTokens.has(token))) return 75;
+  if (tokens.length === 1 && nameTokens.has(tokens[0])) return 65;
+  return 40;
+}
+
+function shapeImessageLookupPayload(raw, options, cached = false, cachedAt = null) {
+  const query = options.name;
+  const selfAlias = Boolean(raw.self_alias);
+  const matches = (raw.matches || [])
+    .map((match) => {
+      const phones = (match.phones || [])
+        .map((phone) => ({
+          label: normalizeContactLabel(phone.label),
+          value: String(phone.value || '').trim(),
+          handle: normalizeImessageHandle(phone.value),
+        }))
+        .filter((phone) => phone.handle);
+      const emails = (match.emails || [])
+        .map((email) => ({
+          label: normalizeContactLabel(email.label),
+          value: String(email.value || '').trim(),
+          handle: String(email.value || '').trim(),
+        }))
+        .filter((email) => email.handle);
+      const handles = [
+        ...phones.map((phone) => ({ type: 'phone', label: phone.label, handle: phone.handle })),
+        ...emails.map((email) => ({ type: 'email', label: email.label, handle: email.handle })),
+      ];
+      return {
+        id: match.id || '',
+        name: match.name || [match.first_name, match.last_name].filter(Boolean).join(' '),
+        phones,
+        emails,
+        handles,
+        primary_handle: handles[0]?.handle || '',
+        score: scoreImessageContact(query, match, selfAlias),
+      };
+    })
+    .filter((match) => match.primary_handle)
+    .sort((a, b) => b.score - a.score || a.name.localeCompare(b.name));
+  const exactMatches = matches.filter((match) => normalizeLookupKey(match.name) === normalizeLookupKey(query));
+  const primary = matches.length === 1
+    ? matches[0]
+    : exactMatches.length === 1
+      ? exactMatches[0]
+      : null;
+  return {
+    ok: true,
+    action: 'imessage_lookup',
+    provider: 'local_contacts',
+    query,
+    cached,
+    cached_at: cachedAt,
+    cache_path: imessageLookupCachePath(),
+    match_count: matches.length,
+    unique: Boolean(primary),
+    ambiguous: matches.length > 1 && !primary,
+    primary: primary ? {
+      name: primary.name,
+      handle: primary.primary_handle,
+      handles: primary.handles,
+    } : null,
+    matches,
+  };
+}
+
+function printImessageLookupPayload(payload, json = false) {
+  if (json) {
+    console.log(JSON.stringify(payload, null, 2));
+    return;
+  }
+  if (!payload.ok) {
+    console.error(payload.error || 'Contact lookup failed.');
+    return;
+  }
+  if (!payload.matches.length) {
+    console.log(`No iMessage contacts found for "${payload.query}".`);
+    return;
+  }
+  if (payload.primary) {
+    console.log(`${payload.primary.name}: ${payload.primary.handle}${payload.cached ? ' (cached)' : ''}`);
+    return;
+  }
+  console.log(`Multiple matches for "${payload.query}":`);
+  for (const match of payload.matches.slice(0, 8)) {
+    console.log(`  - ${match.name}: ${match.primary_handle}`);
+  }
+}
+
+function imessageLookup(args = []) {
+  const options = parseImessageLookupArgs(args);
+  if (!options.name) {
+    printImessageLookupPayload({
+      ok: false,
+      action: 'imessage_lookup',
+      error: 'Usage: atris imessage lookup --name <contact-name> [--json] [--refresh]',
+    }, options.json);
+    process.exit(1);
+  }
+
+  const key = normalizeLookupKey(options.name);
+  const cache = readImessageLookupCache();
+  const entry = cache.entries?.[key];
+  if (!options.refresh && entry && Date.now() - Number(entry.cached_at || 0) <= options.maxAgeMs) {
+    printImessageLookupPayload(shapeImessageLookupPayload(entry.raw, options, true, entry.cached_at), options.json);
+    return;
+  }
+
+  const result = spawnSync('osascript', ['-l', 'JavaScript', '-e', CONTACT_LOOKUP_SCRIPT, options.name], {
+    encoding: 'utf8',
+    timeout: 6000,
+  });
+  if (result.status !== 0) {
+    printImessageLookupPayload({
+      ok: false,
+      action: 'imessage_lookup',
+      query: options.name,
+      error: (result.stderr || 'Contacts lookup failed. Grant Contacts automation permission to this terminal or Atris.').trim(),
+    }, options.json);
+    process.exit(1);
+  }
+
+  let raw;
+  try {
+    raw = JSON.parse(String(result.stdout || '{}'));
+  } catch {
+    printImessageLookupPayload({
+      ok: false,
+      action: 'imessage_lookup',
+      query: options.name,
+      error: 'Contacts lookup returned invalid JSON.',
+    }, options.json);
+    process.exit(1);
+  }
+
+  const cachedAt = Date.now();
+  const latestCache = readImessageLookupCache();
+  latestCache.version = 1;
+  latestCache.entries = latestCache.entries || {};
+  latestCache.entries[key] = { cached_at: cachedAt, raw };
+  writeImessageLookupCache(latestCache);
+  printImessageLookupPayload(shapeImessageLookupPayload(raw, options, false, cachedAt), options.json);
+}
+
+function parseImessageSendArgs(args) {
+  const options = {
+    approved: false,
+    json: false,
+    receipt: false,
+    to: '',
+    text: '',
+  };
+  const positional = [];
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === '--approved' || arg === '--confirm-approved') {
+      options.approved = true;
+    } else if (arg === '--json') {
+      options.json = true;
+    } else if (arg === '--receipt') {
+      options.receipt = true;
+    } else if (arg === '--to' || arg === '--handle') {
+      options.to = args[i + 1] || '';
+      i += 1;
+    } else if (arg === '--text' || arg === '--message') {
+      options.text = args[i + 1] || '';
+      i += 1;
+    } else {
+      positional.push(arg);
+    }
+  }
+  if (!options.to && positional.length) options.to = positional.shift() || '';
+  if (!options.text && positional.length) options.text = positional.join(' ');
+  options.to = normalizeImessageHandle(options.to);
+  options.text = String(options.text || '').trim();
+  return options;
+}
+
+function printImessageSendPayload(payload, json = false) {
+  if (json) {
+    console.log(JSON.stringify(payload, null, 2));
+    return;
+  }
+  if (payload.ok) {
+    console.log(`Sent iMessage to ${payload.to}.`);
+    if (payload.receipt_path) console.log(`Receipt: ${payload.receipt_path}`);
+  } else {
+    console.error(payload.error || 'Failed to send iMessage.');
+  }
+}
+
+function writeImessageSendReceipt(payload) {
+  const atrisDir = path.join(process.cwd(), 'atris');
+  if (!fs.existsSync(atrisDir)) return '';
+  const runsDir = path.join(atrisDir, 'runs');
+  fs.mkdirSync(runsDir, { recursive: true });
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const receiptPath = path.join(runsDir, `imessage-send-${stamp}.md`);
+  const lines = [
+    '# iMessage Send Receipt',
+    '',
+    `- Sent at: ${payload.sent_at}`,
+    `- Provider: ${payload.provider}`,
+    `- To: ${payload.to}`,
+    `- Text: ${payload.text}`,
+    `- Doctor connected: ${payload.doctor?.connected === true}`,
+    `- Send exit: ${payload.osascript?.status}`,
+    `- DB verified: ${payload.db_verification?.matched === true}`,
+    `- DB settled: ${payload.db_verification?.settled === true}`,
+  ];
+  fs.writeFileSync(receiptPath, `${lines.join('\n')}\n`, 'utf8');
+  return receiptPath;
+}
+
+function imessageSend(args = []) {
+  const options = parseImessageSendArgs(args);
+  const basePayload = {
+    ok: false,
+    action: 'imessage_send',
+    provider: 'local_imessage',
+    to: options.to,
+    text: options.text,
+    approved: options.approved,
+  };
+
+  if (!options.to || !options.text) {
+    printImessageSendPayload({
+      ...basePayload,
+      error: 'Usage: atris imessage send --to <phone-or-email> --text <message> --approved [--json] [--receipt]',
+    }, options.json);
+    process.exit(1);
+  }
+
+  if (!options.approved) {
+    printImessageSendPayload({
+      ...basePayload,
+      error: 'Refusing to send without --approved after the exact recipient and exact text are confirmed.',
+    }, options.json);
+    process.exit(1);
+  }
+
+  const doctor = imessageDoctor();
+  if (!doctor.connected) {
+    printImessageSendPayload({
+      ...basePayload,
+      doctor,
+      error: 'iMessage is not available on this Mac.',
+    }, options.json);
+    process.exit(1);
+  }
+
+  const sendStartedAt = Date.now();
+  const result = spawnSync('osascript', [
+    '-e', 'on run argv',
+    '-e', 'set targetHandle to item 1 of argv',
+    '-e', 'set messageText to item 2 of argv',
+    '-e', 'tell application "Messages"',
+    '-e', 'set targetService to 1st service whose service type = iMessage',
+    '-e', 'set targetBuddy to buddy targetHandle of targetService',
+    '-e', 'send messageText to targetBuddy',
+    '-e', 'end tell',
+    '-e', 'return targetHandle',
+    '-e', 'end run',
+    options.to,
+    options.text,
+  ], {
+    encoding: 'utf8',
+    timeout: 10000,
+  });
+
+  const payload = {
+    ...basePayload,
+    ok: result.status === 0,
+    sent_at: new Date().toISOString(),
+    doctor: {
+      connected: doctor.connected,
+      checks: doctor.checks,
+    },
+    osascript: {
+      status: result.status,
+      signal: result.signal || null,
+      stdout: String(result.stdout || '').trim(),
+      stderr: String(result.stderr || '').trim(),
+    },
+  };
+
+  if (payload.ok) {
+    payload.db_verification = imessageVerifyLatestOutgoing(options.to, sendStartedAt);
+  }
+
+  if (payload.ok && options.receipt) {
+    payload.receipt_path = writeImessageSendReceipt(payload);
+  }
+
+  if (!payload.ok) {
+    payload.error = payload.osascript.stderr || 'Messages AppleScript send failed.';
+  }
+
+  printImessageSendPayload(payload, options.json);
+  if (!payload.ok) process.exit(1);
+}
+
 async function imessageCommand(subcommand, ...args) {
   switch (subcommand) {
     case 'doctor': {
@@ -434,10 +948,20 @@ async function imessageCommand(subcommand, ...args) {
       imessageRecent(handle, { limit, json: args.includes('--json') });
       break;
     }
+    case 'lookup': {
+      imessageLookup(args);
+      break;
+    }
+    case 'send': {
+      imessageSend(args);
+      break;
+    }
     default:
       console.log('iMessage commands:');
       console.log('  atris imessage doctor [--json]   - Check local Messages access');
+      console.log('  atris imessage lookup --name <name> [--json] [--refresh]');
       console.log('  atris imessage recent <handle>   - Read recent local messages');
+      console.log('  atris imessage send --to <handle> --text <text> --approved [--json] [--receipt]');
   }
 }
 

package/commands/learn.js

@@ -68,7 +68,7 @@ function showSearch(query) {
   }
 
   console.log('');
-  console.log(`  Search: "${query}" — ${results.length} result(s)`);
+  console.log(`  Search: "${query}" — ${results.length} ${results.length === 1 ? 'result' : 'results'}`);
   console.log('');
   for (const e of results) {
     const conf = e._effectiveConfidence;
@@ -316,7 +316,7 @@ function harvestFromJournals() {
   }
 
   console.log('');
-  console.log(`  Found ${fresh.length} new note(s) to harvest:`);
+  console.log(`  Found ${fresh.length} new ${fresh.length === 1 ? 'note' : 'notes'} to harvest:`);
   console.log('');
   for (let i = 0; i < fresh.length; i++) {
     const c = fresh[i];
@@ -347,7 +347,29 @@ function getLearningCount() {
 /**
  * Main entry point for `atris learn [subcommand] [args]`
  */
+function showLearnHelp() {
+  console.log('');
+  console.log('  Usage: atris learn [command]');
+  console.log('');
+  console.log('  Commands:');
+  console.log('    (none)     Show recent learnings');
+  console.log('    add        Add a learning interactively');
+  console.log('    log <json> Add programmatically (for agents)');
+  console.log('    search <q> Search learnings by keyword');
+  console.log('    harvest    Extract learnings from journal Notes');
+  console.log('    prune      Check for stale/contradictory entries');
+  console.log('    stats      Show learning statistics');
+  console.log('    export     Export as markdown');
+  console.log('    count      Print learning count (for integrations)');
+  console.log('');
+}
+
 function learnAtris(subcommand, ...args) {
+  if (subcommand === 'help' || subcommand === '--help' || subcommand === '-h' || args.includes('--help') || args.includes('-h')) {
+    showLearnHelp();
+    return;
+  }
+
   const atrisDir = path.join(process.cwd(), 'atris');
   if (!fs.existsSync(atrisDir)) {
     console.error('  ✗ atris/ folder not found. Run "atris init" first.');
@@ -384,20 +406,7 @@ function learnAtris(subcommand, ...args) {
       harvestFromJournals();
       break;
     default:
-      console.log('');
-      console.log('  Usage: atris learn [command]');
-      console.log('');
-      console.log('  Commands:');
-      console.log('    (none)     Show recent learnings');
-      console.log('    add        Add a learning interactively');
-      console.log('    log <json> Add programmatically (for agents)');
-      console.log('    search <q> Search learnings by keyword');
-      console.log('    harvest    Extract learnings from journal Notes');
-      console.log('    prune      Check for stale/contradictory entries');
-      console.log('    stats      Show learning statistics');
-      console.log('    export     Export as markdown');
-      console.log('    count      Print learning count (for integrations)');
-      console.log('');
+      showLearnHelp();
       break;
   }
 }

package/commands/lesson.js

@@ -0,0 +1,41 @@
+const fs = require('fs');
+const path = require('path');
+const { writeLesson } = require('./autopilot');
+
+function lessonAtris(subcommand, ...args) {
+  const atrisDir = path.join(process.cwd(), 'atris');
+  if (!fs.existsSync(atrisDir)) {
+    console.error('  ✗ atris/ folder not found. Run "atris init" first.');
+    process.exit(1);
+  }
+
+  if (subcommand !== 'add') {
+    console.log('');
+    console.log('  Usage: atris lesson add <slug> <pass|fail> "<text>"');
+    console.log('');
+    process.exit(subcommand ? 1 : 0);
+  }
+
+  const [slug, status, ...messageParts] = args;
+  const explanation = messageParts.join(' ').trim();
+
+  if (!slug || !/^[a-z0-9-]+$/.test(slug)) {
+    console.error('  ✗ slug must be kebab-case');
+    process.exit(1);
+  }
+
+  if (!['pass', 'fail'].includes(status)) {
+    console.error('  ✗ status must be "pass" or "fail"');
+    process.exit(1);
+  }
+
+  if (!explanation) {
+    console.error('  ✗ explanation is required');
+    process.exit(1);
+  }
+
+  writeLesson(process.cwd(), slug, status, explanation);
+  console.log(`✓ lesson added: ${slug} (${status})`);
+}
+
+module.exports = lessonAtris;

package/commands/lifecycle.js

@@ -29,7 +29,7 @@ function resolveSlug() {
 async function sleepAtris() {
   const slug = resolveSlug();
 
-  if (!slug || slug === '--help') {
+  if (!slug || slug === '--help' || slug === '-h' || slug === 'help') {
     console.log('Usage: atris sleep [business]');
     console.log('');
     console.log('  Pause a workspace to save compute. Storage only.');
@@ -60,7 +60,7 @@ async function sleepAtris() {
 async function wakeAtris() {
   const slug = resolveSlug();
 
-  if (!slug || slug === '--help') {
+  if (!slug || slug === '--help' || slug === '-h' || slug === 'help') {
     console.log('Usage: atris wake [business]');
     console.log('');
     console.log('  Wake a sleeping workspace. Agents resume automatically.');