atris 3.14.0 → 3.15.11

package/commands/init.js

@@ -423,6 +423,13 @@ function initAtris() {
     console.log('✓ Created TODO.md placeholder');
   }
 
+  const nowFile = path.join(targetDir, 'now.md');
+  if (!fs.existsSync(nowFile)) {
+    const { renderDefaultNow } = require('./now');
+    fs.writeFileSync(nowFile, renderDefaultNow(cwd), 'utf8');
+    console.log('✓ Created now.md');
+  }
+
   // Create lessons.md (feedback loop for learning across features)
   const lessonsFile = path.join(targetDir, 'lessons.md');
   if (!fs.existsSync(lessonsFile)) {
@@ -605,7 +612,9 @@ This is the Atris boot sequence. Show the output to the user, then respond natur
 | File | Purpose |
 |------|---------|
 | \`atris/PERSONA.md\` | Communication style (read first) |
-| \`atris/TODO.md\` | Current tasks |
+| \`atris task\` | Current tasks, claims, dialogue, proof |
+| \`.atris/state/tasks.projection.json\` | Readable task projection for UIs/agents |
+| \`atris/TODO.md\` | Rendered/legacy task view only |
 | \`atris/MAP.md\` | Navigation (where is X?) |
 
 ## Workflow
@@ -621,14 +630,17 @@ CHECK → atris review (verify + cleanup)
 - [ ] 3-4 sentences max per response
 - [ ] Use ASCII visuals for planning
 - [ ] Check MAP.md before touching code
-- [ ] Claim tasks in TODO.md before working
-- [ ] Delete tasks when done
+- [ ] Run \`atris task list\` or \`atris task next\` before picking work
+- [ ] Claim tasks with \`atris task claim <id> --as <agent>\`
+- [ ] Finish tasks with proof via \`atris task finish <id> --proof "..."\`
+- [ ] Treat \`atris/TODO.md\` as a rendered view; do not manually use it as the source of truth
 
 ## Anti-patterns
 
 - Don't explore codebase manually (use MAP.md)
 - Don't skip visualization step
 - Don't leave stale tasks
+- Don't hand-edit TODO.md for active task ownership
 - Don't write verbose docs
 
 ---

package/commands/integrations.js

@@ -12,6 +12,10 @@
 
 const { loadCredentials, ensureValidCredentials } = require('../utils/auth');
 const { apiRequestJson } = require('../utils/api');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
 
 async function getAuth() {
   const ensured = await ensureValidCredentials(apiRequestJson);
@@ -310,6 +314,125 @@ async function slackCommand(subcommand, ...args) {
   }
 }
 
+// ============================================================================
+// IMESSAGE
+// ============================================================================
+
+function imessageDoctor() {
+  const chatDb = path.join(os.homedir(), 'Library', 'Messages', 'chat.db');
+  const checks = {
+    macos: process.platform === 'darwin',
+    chat_db_exists: false,
+    chat_db_readable: false,
+    sqlite3_available: false,
+    osascript_available: false,
+  };
+  const issues = [];
+
+  checks.chat_db_exists = fs.existsSync(chatDb);
+  if (checks.chat_db_exists) {
+    try {
+      fs.accessSync(chatDb, fs.constants.R_OK);
+      checks.chat_db_readable = true;
+    } catch {
+      issues.push('Messages database exists but is not readable. Grant Full Disk Access to this terminal or Atris.');
+    }
+  } else {
+    issues.push('Messages database not found on this Mac.');
+  }
+
+  checks.sqlite3_available = spawnSync('sqlite3', ['--version'], { encoding: 'utf8' }).status === 0;
+  if (!checks.sqlite3_available) issues.push('sqlite3 is not available.');
+
+  checks.osascript_available = spawnSync('osascript', ['-e', 'return "ok"'], { encoding: 'utf8' }).status === 0;
+  if (!checks.osascript_available) issues.push('osascript is not available.');
+
+  if (!checks.macos) issues.push('Local iMessage requires macOS.');
+
+  const connected = checks.macos && checks.chat_db_exists && checks.chat_db_readable && checks.sqlite3_available && checks.osascript_available;
+  return {
+    connected,
+    provider: 'local_imessage',
+    mode: 'local',
+    checks,
+    issues,
+    next_step: connected
+      ? 'iMessage is available on this Mac.'
+      : 'Open System Settings -> Privacy & Security -> Full Disk Access and allow your terminal or Atris, then run this check again.',
+  };
+}
+
+function printImessageDoctor(result, json = false) {
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log('iMessage local check\n');
+  console.log(`Status: ${result.connected ? 'Connected on this Mac' : 'Needs permission or setup'}`);
+  for (const [name, ok] of Object.entries(result.checks)) {
+    console.log(`  ${ok ? '✓' : '✗'} ${name.replace(/_/g, ' ')}`);
+  }
+  if (result.issues.length) {
+    console.log('\nNext:');
+    for (const issue of result.issues) console.log(`  - ${issue}`);
+    console.log(`  - ${result.next_step}`);
+  }
+}
+
+function imessageRecent(handle, options = {}) {
+  if (!handle) {
+    console.error('Usage: atris imessage recent <phone-or-email> [--limit 20]');
+    process.exit(1);
+  }
+  const doctor = imessageDoctor();
+  if (!doctor.connected) {
+    printImessageDoctor(doctor, Boolean(options.json));
+    process.exit(1);
+  }
+
+  const limit = Number(options.limit || 20);
+  const chatDb = path.join(os.homedir(), 'Library', 'Messages', 'chat.db');
+  const sql = `
+    SELECT datetime(m.date/1000000000 + 978307200, 'unixepoch', 'localtime') AS ts,
+           CASE m.is_from_me WHEN 1 THEN 'me' ELSE h.id END AS sender,
+           replace(replace(COALESCE(m.text,''), char(10), ' '), char(13), ' ') AS text
+    FROM message m
+    JOIN handle h ON h.rowid = m.handle_id
+    WHERE h.id = '${String(handle).replace(/'/g, "''")}'
+    ORDER BY m.date DESC
+    LIMIT ${Math.max(1, Math.min(100, limit))};
+  `;
+  const result = spawnSync('sqlite3', ['-readonly', chatDb, sql], { encoding: 'utf8' });
+  if (result.status !== 0) {
+    console.error(result.stderr || 'Failed to read Messages database.');
+    process.exit(1);
+  }
+  console.log(result.stdout.trim() || 'No recent messages found.');
+}
+
+async function imessageCommand(subcommand, ...args) {
+  switch (subcommand) {
+    case 'doctor': {
+      const json = args.includes('--json');
+      const result = imessageDoctor();
+      printImessageDoctor(result, json);
+      if (!result.connected && args.includes('--strict')) process.exit(1);
+      break;
+    }
+    case 'recent': {
+      const handle = args[0];
+      const limitFlag = args.findIndex((x) => x === '--limit');
+      const limit = limitFlag >= 0 ? args[limitFlag + 1] : 20;
+      imessageRecent(handle, { limit, json: args.includes('--json') });
+      break;
+    }
+    default:
+      console.log('iMessage commands:');
+      console.log('  atris imessage doctor [--json]   - Check local Messages access');
+      console.log('  atris imessage recent <handle>   - Read recent local messages');
+  }
+}
+
 // ============================================================================
 // STATUS
 // ============================================================================
@@ -337,6 +460,9 @@ async function integrationsStatus() {
     }
   }
 
+  const imessage = imessageDoctor();
+  console.log(`  ${imessage.connected ? '✅' : '❌'} iMessage (local Mac)`);
+
   console.log('\nConnect integrations at: https://atris.ai/dashboard/settings');
 }
 
@@ -345,5 +471,7 @@ module.exports = {
   calendarCommand,
   twitterCommand,
   slackCommand,
+  imessageCommand,
+  imessageDoctor,
   integrationsStatus,
 };

package/commands/live.js

@@ -0,0 +1,311 @@
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const DEFAULT_INTERVAL_SEC = 120;
+const DEFAULT_DEBOUNCE_SEC = 30;
+const DEFAULT_TIMEOUT_SEC = 600;
+
+const IGNORED_DIRS = new Set(['.git', 'node_modules', 'dist', 'build', 'release', '.next', '__pycache__']);
+const IGNORED_FILES = new Set(['.DS_Store']);
+
+function parseNumberFlag(args, name, fallback) {
+  const eq = args.find((arg) => arg.startsWith(`--${name}=`));
+  if (eq) {
+    const value = Number(eq.slice(name.length + 3));
+    return Number.isFinite(value) && value > 0 ? value : fallback;
+  }
+  const idx = args.indexOf(`--${name}`);
+  if (idx !== -1 && args[idx + 1]) {
+    const value = Number(args[idx + 1]);
+    return Number.isFinite(value) && value > 0 ? value : fallback;
+  }
+  return fallback;
+}
+
+function parseStringFlag(args, name) {
+  const eq = args.find((arg) => arg.startsWith(`--${name}=`));
+  if (eq) return eq.slice(name.length + 3);
+  const idx = args.indexOf(`--${name}`);
+  if (idx !== -1 && args[idx + 1] && !args[idx + 1].startsWith('-')) return args[idx + 1];
+  return null;
+}
+
+function firstPositionalArg(args) {
+  const flagsWithValues = new Set(['--interval', '--debounce', '--timeout', '--only', '--root']);
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (flagsWithValues.has(arg)) {
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith('-')) continue;
+    return arg;
+  }
+  return null;
+}
+
+function readBusinessMetaFromCwd(cwd) {
+  const file = path.join(cwd, '.atris', 'business.json');
+  if (!fs.existsSync(file)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function readBusinessSlugFromCwd(cwd) {
+  const data = readBusinessMetaFromCwd(cwd);
+  return data ? data.slug || data.canonical_slug || data.name || null : null;
+}
+
+function resolveWorkspaceCwd(slug, cwd) {
+  if (!slug) return cwd;
+
+  const currentSlug = readBusinessSlugFromCwd(cwd);
+  if (currentSlug === slug) return cwd;
+
+  const child = path.join(cwd, slug);
+  if (fs.existsSync(child) && fs.statSync(child).isDirectory()) {
+    const childSlug = readBusinessSlugFromCwd(child);
+    const hasAtris = fs.existsSync(path.join(child, 'atris'));
+    if (childSlug || hasAtris) return child;
+  }
+
+  return cwd;
+}
+
+function parseLiveOptions(args, cwd = process.cwd()) {
+  const first = firstPositionalArg(args);
+  const slug = first || readBusinessSlugFromCwd(cwd);
+  const workspaceCwd = resolveWorkspaceCwd(slug, cwd);
+  return {
+    slug,
+    once: args.includes('--once'),
+    dryRun: args.includes('--dry-run'),
+    noDoctor: args.includes('--no-doctor'),
+    noPush: args.includes('--no-push'),
+    intervalSec: parseNumberFlag(args, 'interval', DEFAULT_INTERVAL_SEC),
+    debounceSec: parseNumberFlag(args, 'debounce', DEFAULT_DEBOUNCE_SEC),
+    timeoutSec: parseNumberFlag(args, 'timeout', DEFAULT_TIMEOUT_SEC),
+    only: parseStringFlag(args, 'only'),
+    root: parseStringFlag(args, 'root') || path.dirname(workspaceCwd),
+    cwd: workspaceCwd,
+  };
+}
+
+function printLiveHelp() {
+  console.log('Usage: atris live [business] [options]');
+  console.log('');
+  console.log('Keeps a business brain fresh: doctor, pull, watch local changes, push after quiet, and periodically pull.');
+  console.log('');
+  console.log('Examples:');
+  console.log('  atris live atris-labs');
+  console.log('  atris live --once');
+  console.log('  atris live atris-labs --dry-run');
+  console.log('  atris live atris-labs --interval=120 --debounce=30');
+  console.log('');
+  console.log('Options:');
+  console.log('  --once             Run one freshness cycle and exit');
+  console.log('  --dry-run          Print the plan without running pull/push');
+  console.log('  --interval <sec>   Seconds between cloud pulls (default: 120)');
+  console.log('  --debounce <sec>   Quiet seconds before pushing local changes (default: 30)');
+  console.log('  --timeout <sec>    Pull timeout passed through to atris pull (default: 600)');
+  console.log('  --only <prefix>    Limit pull/push to a path prefix');
+  console.log('  --no-doctor        Skip business doctor --fix');
+  console.log('  --no-push          Pull/watch only; never push');
+}
+
+function shouldIgnore(relativePath) {
+  if (!relativePath) return true;
+  const parts = relativePath.split(path.sep);
+  if (parts.some((part) => IGNORED_DIRS.has(part))) return true;
+  if (IGNORED_FILES.has(path.basename(relativePath))) return true;
+  if (relativePath.startsWith(path.join('.atris', 'state'))) return true;
+  return false;
+}
+
+function collectSnapshot(root) {
+  const snapshot = new Map();
+
+  function walk(dir) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      const rel = path.relative(root, full);
+      if (shouldIgnore(rel)) continue;
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (entry.isFile()) {
+        try {
+          const stat = fs.statSync(full);
+          snapshot.set(rel, `${stat.size}:${Math.floor(stat.mtimeMs)}`);
+        } catch {
+          // Files can disappear while the operator is saving.
+        }
+      }
+    }
+  }
+
+  walk(root);
+  return snapshot;
+}
+
+function snapshotsDiffer(a, b) {
+  if (a.size !== b.size) return true;
+  for (const [key, value] of a.entries()) {
+    if (b.get(key) !== value) return true;
+  }
+  return false;
+}
+
+function commandLine(argv) {
+  return ['atris', ...argv].join(' ');
+}
+
+function runCli(argv, options) {
+  if (options.dryRun) {
+    console.log(`  dry-run: ${commandLine(argv)}`);
+    return Promise.resolve({ status: 0 });
+  }
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [path.join(__dirname, '..', 'bin', 'atris.js'), ...argv], {
+      cwd: options.cwd,
+      stdio: 'inherit',
+      env: { ...process.env, ATRIS_SKIP_UPDATE_CHECK: '1' },
+    });
+    child.on('error', reject);
+    child.on('exit', (status) => {
+      if (status === 0) resolve({ status });
+      else reject(new Error(`${commandLine(argv)} exited ${status}`));
+    });
+  });
+}
+
+function buildPullArgs(options) {
+  const args = ['pull', options.slug, '--timeout', String(options.timeoutSec)];
+  if (options.only) args.push('--only', options.only);
+  return args;
+}
+
+function buildPushArgs(options) {
+  const args = ['push', options.slug, '--from', options.cwd];
+  if (options.only) args.push('--only', options.only);
+  return args;
+}
+
+async function runFreshnessCycle(options, reason) {
+  console.log('');
+  console.log(`atris live: ${reason}`);
+  if (!options.noDoctor) {
+    await runCli(['business', 'doctor', '--fix', '--root', options.root], options);
+  }
+  if (!options.noPush) {
+    await runCli(buildPushArgs(options), options);
+  }
+  await runCli(buildPullArgs(options), options);
+}
+
+async function liveCommand(args = process.argv.slice(3)) {
+  if (args.includes('--help') || args.includes('-h') || args[0] === 'help') {
+    printLiveHelp();
+    return;
+  }
+
+  const options = parseLiveOptions(args);
+  if (!options.slug) {
+    console.error('Usage: atris live [business]');
+    console.error('Run inside a business workspace or pass a business slug.');
+    process.exit(1);
+  }
+
+  console.log('');
+  console.log(`Atris Live: ${options.slug}`);
+  console.log(`  workspace: ${options.cwd}`);
+  console.log(`  interval: ${options.intervalSec}s`);
+  console.log(`  debounce: ${options.debounceSec}s`);
+  console.log(`  push: ${options.noPush ? 'off' : 'on'}`);
+  if (options.only) console.log(`  only: ${options.only}`);
+
+  if (options.dryRun) {
+    await runFreshnessCycle(options, 'planned startup cycle');
+    if (!options.once) console.log(`  dry-run: would watch ${options.cwd} and sync every ${options.intervalSec}s`);
+    return;
+  }
+
+  await runFreshnessCycle(options, 'startup freshness cycle');
+  if (options.once) return;
+
+  console.log('');
+  console.log('Brain fresh. Watching for local changes. Press Ctrl+C to stop.');
+
+  let lastSnapshot = collectSnapshot(options.cwd);
+  let pendingPush = false;
+  let quietTicks = 0;
+  let running = false;
+
+  async function guarded(label, fn) {
+    if (running) return;
+    running = true;
+    try {
+      await fn();
+      lastSnapshot = collectSnapshot(options.cwd);
+      pendingPush = false;
+      quietTicks = 0;
+    } catch (err) {
+      console.error(`\natris live paused after ${label}: ${err.message || err}`);
+      console.error('Fix the issue, then restart `atris live`.');
+      process.exit(1);
+    } finally {
+      running = false;
+    }
+  }
+
+  setInterval(() => {
+    if (running) return;
+    const current = collectSnapshot(options.cwd);
+    if (snapshotsDiffer(lastSnapshot, current)) {
+      pendingPush = true;
+      quietTicks = 0;
+      lastSnapshot = current;
+      process.stdout.write('\rLocal brain changed. Waiting for quiet before push... ');
+      return;
+    }
+    if (pendingPush) {
+      quietTicks += 1;
+      if (quietTicks >= options.debounceSec) {
+        void guarded('push', async () => {
+          console.log('\nLocal brain quiet. Pushing fresh state...');
+          if (!options.noPush) await runCli(buildPushArgs(options), options);
+        });
+      }
+    }
+  }, 1000);
+
+  setInterval(() => {
+    if (pendingPush) {
+      process.stdout.write('\rLocal changes pending; skipping cloud pull until local brain is pushed... ');
+      return;
+    }
+    void guarded('periodic pull', async () => {
+      console.log('\nChecking cloud for fresher brain...');
+      await runCli(buildPullArgs(options), options);
+    });
+  }, options.intervalSec * 1000);
+}
+
+module.exports = {
+  collectSnapshot,
+  liveCommand,
+  parseLiveOptions,
+  shouldIgnore,
+  snapshotsDiffer,
+};