atris 3.15.0 → 3.15.12

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,133 @@ 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,
+    messages_automation: 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.osascript_available) {
+    checks.messages_automation = spawnSync('osascript', ['-e', 'tell application "Messages" to count services'], {
+      encoding: 'utf8',
+      timeout: 4000,
+    }).status === 0;
+  }
+  if (!checks.messages_automation) issues.push('Messages automation permission is not available yet.');
+
+  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 && checks.messages_automation;
+  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 +468,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 +479,7 @@ module.exports = {
   calendarCommand,
   twitterCommand,
   slackCommand,
+  imessageCommand,
+  imessageDoctor,
   integrationsStatus,
 };

package/commands/live.js

@@ -45,21 +45,43 @@ function firstPositionalArg(args) {
   return null;
 }
 
-function readBusinessSlugFromCwd(cwd) {
+function readBusinessMetaFromCwd(cwd) {
   const file = path.join(cwd, '.atris', 'business.json');
   if (!fs.existsSync(file)) return null;
   try {
-    const data = JSON.parse(fs.readFileSync(file, 'utf8'));
-    return data.slug || data.canonical_slug || data.name || null;
+    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: first || readBusinessSlugFromCwd(cwd),
+    slug,
     once: args.includes('--once'),
     dryRun: args.includes('--dry-run'),
     noDoctor: args.includes('--no-doctor'),
@@ -68,8 +90,8 @@ function parseLiveOptions(args, cwd = process.cwd()) {
     debounceSec: parseNumberFlag(args, 'debounce', DEFAULT_DEBOUNCE_SEC),
     timeoutSec: parseNumberFlag(args, 'timeout', DEFAULT_TIMEOUT_SEC),
     only: parseStringFlag(args, 'only'),
-    root: parseStringFlag(args, 'root') || path.dirname(cwd),
-    cwd,
+    root: parseStringFlag(args, 'root') || path.dirname(workspaceCwd),
+    cwd: workspaceCwd,
   };
 }
 

package/commands/now.js

@@ -0,0 +1,263 @@
+const fs = require('fs');
+const path = require('path');
+
+const NOW_PATH = path.join('atris', 'now.md');
+
+function todayIso() {
+  return new Date().toISOString().split('T')[0];
+}
+
+function ensureAtrisDir(root = process.cwd()) {
+  const atrisDir = path.join(root, 'atris');
+  if (!fs.existsSync(atrisDir)) {
+    throw new Error('atris/ folder not found. Run "atris init" first.');
+  }
+  return atrisDir;
+}
+
+function hasWorkspaceMarkers(atrisDir) {
+  return fs.existsSync(path.join(atrisDir, 'MAP.md')) || fs.existsSync(path.join(atrisDir, 'TODO.md'));
+}
+
+function findChildWorkspaces(root = process.cwd()) {
+  if (!fs.existsSync(root)) return [];
+
+  return fs
+    .readdirSync(root, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && !entry.name.startsWith('.'))
+    .map((entry) => {
+      const workspaceRoot = path.join(root, entry.name);
+      const atrisDir = path.join(workspaceRoot, 'atris');
+      if (!fs.existsSync(atrisDir) || !hasWorkspaceMarkers(atrisDir)) return null;
+      const mapPath = path.join(atrisDir, 'MAP.md');
+      const todoPath = path.join(atrisDir, 'TODO.md');
+      return {
+        slug: entry.name,
+        root: workspaceRoot,
+        atrisDir,
+        mapPath,
+        todoPath,
+        nowPath: path.join(atrisDir, 'now.md'),
+      };
+    })
+    .filter(Boolean)
+    .sort((a, b) => a.slug.localeCompare(b.slug));
+}
+
+function readFirstHeading(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  const content = fs.readFileSync(filePath, 'utf8');
+  const line = content.split(/\r?\n/).find((l) => l.trim().startsWith('#'));
+  return line ? line.replace(/^#+\s*/, '').trim() : null;
+}
+
+function countMatches(filePath, pattern) {
+  if (!fs.existsSync(filePath)) return 0;
+  const content = fs.readFileSync(filePath, 'utf8');
+  return (content.match(pattern) || []).length;
+}
+
+function currentJournalPath(root = process.cwd()) {
+  const now = new Date();
+  const year = String(now.getFullYear());
+  const date = todayIso();
+  return path.join(root, 'atris', 'logs', year, `${date}.md`);
+}
+
+function renderDefaultNow(root = process.cwd()) {
+  const atrisDir = ensureAtrisDir(root);
+  const mapHeading = readFirstHeading(path.join(atrisDir, 'MAP.md')) || 'MAP not filled yet';
+  const todoPath = path.join(atrisDir, 'TODO.md');
+  const journalPath = currentJournalPath(root);
+  const backlogCount = countMatches(todoPath, /^-\s+\*\*.+?\*\*/gm);
+  const inboxCount = countMatches(journalPath, /^-\s+\*\*I\d+:/gm);
+  const completedCount = countMatches(journalPath, /^-\s+\*\*C\d+:/gm);
+  const generated = todayIso();
+
+  return `# now
+
+> Current operating truth for this workspace.
+> Read this first. Follow links only when needed.
+
+Last updated: ${generated}
+
+## What Matters Now
+
+- Decide the next useful move before opening more context.
+
+## Current Priority
+
+- Keep the workspace coherent and useful for the next human or agent.
+
+## Signals
+
+- Map: ${mapHeading}
+- TODO items visible: ${backlogCount}
+- Inbox items today: ${inboxCount}
+- Completed receipts today: ${completedCount}
+
+## Watchouts
+
+- Do not treat old logs as current truth unless this file links to them.
+- Do not create motion for its own sake.
+- If facts conflict, surface the conflict and cite the receipts.
+
+## Next Move
+
+- Read \`atris/MAP.md\`, \`atris/TODO.md\`, and today's journal only as needed for the task in front of you.
+
+## Receipts
+
+- \`atris/MAP.md\`
+- \`atris/TODO.md\`
+- \`${path.relative(root, journalPath)}\`
+`;
+}
+
+function renderPortfolioNow(root = process.cwd()) {
+  const workspaces = findChildWorkspaces(root);
+  if (workspaces.length === 0) {
+    throw new Error('atris/ folder not found. Run "atris init" first.');
+  }
+
+  const generated = todayIso();
+  const lines = workspaces.map((workspace) => {
+    const heading = readFirstHeading(workspace.mapPath) || workspace.slug;
+    const todoCount = countMatches(workspace.todoPath, /^-\s+\*\*.+?\*\*/gm);
+    const nowState = fs.existsSync(workspace.nowPath) ? 'has now.md' : 'needs now.md';
+    return `- ${workspace.slug}: ${heading}; ${todoCount} visible TODO item${todoCount === 1 ? '' : 's'}; ${nowState}.`;
+  });
+
+  return `# now
+
+> Current operating truth for this portfolio of Atris workspaces.
+> Read this first. Then enter the specific workspace that matters.
+
+Last updated: ${generated}
+
+## What Matters Now
+
+- Keep the active business workspaces easy to scan, update, and hand off.
+
+## Current Priority
+
+- Use the child workspace with the right slug; avoid creating duplicate business brains.
+
+## Workspace Signals
+
+${lines.join('\n')}
+
+## Watchouts
+
+- Parent status is a map, not the source of truth for each business.
+- Each active workspace should own its own \`atris/now.md\`.
+- If slugs conflict, resolve the workspace identity before pushing or pulling.
+
+## Next Move
+
+- Run \`atris now\` inside the workspace you are about to operate.
+
+## Receipts
+
+${workspaces.map((workspace) => `- \`${workspace.slug}/atris/MAP.md\``).join('\n')}
+`;
+}
+
+function ensureNowFile(root = process.cwd()) {
+  let atrisDir = path.join(root, 'atris');
+  const isWorkspace = fs.existsSync(atrisDir) && hasWorkspaceMarkers(atrisDir);
+  const childWorkspaces = isWorkspace ? [] : findChildWorkspaces(root);
+  if (!isWorkspace && childWorkspaces.length === 0) {
+    ensureAtrisDir(root);
+  }
+  if (!isWorkspace && childWorkspaces.length > 0) {
+    fs.mkdirSync(atrisDir, { recursive: true });
+  }
+  const nowPath = path.join(atrisDir, 'now.md');
+  if (!fs.existsSync(nowPath)) {
+    const content = isWorkspace ? renderDefaultNow(root) : renderPortfolioNow(root);
+    fs.writeFileSync(nowPath, content, 'utf8');
+    return { created: true, path: nowPath };
+  }
+  return { created: false, path: nowPath };
+}
+
+function refreshNowFile(root = process.cwd()) {
+  const atrisDir = path.join(root, 'atris');
+  const isWorkspace = fs.existsSync(atrisDir) && hasWorkspaceMarkers(atrisDir);
+  const childWorkspaces = isWorkspace ? [] : findChildWorkspaces(root);
+  if (!isWorkspace && childWorkspaces.length === 0) {
+    ensureAtrisDir(root);
+  }
+  if (!isWorkspace && childWorkspaces.length > 0) {
+    fs.mkdirSync(atrisDir, { recursive: true });
+  }
+  const nowPath = path.join(atrisDir, 'now.md');
+  const content = isWorkspace ? renderDefaultNow(root) : renderPortfolioNow(root);
+  fs.writeFileSync(nowPath, content, 'utf8');
+  return { path: nowPath };
+}
+
+function nowAtris(args = process.argv.slice(3), root = process.cwd()) {
+  const help = args.includes('--help') || args.includes('-h');
+  if (help) {
+    console.log('Usage: atris now [--init|--refresh|--all|--path]');
+    console.log('');
+    console.log('Show the current operating truth for this workspace.');
+    console.log('');
+    console.log('  atris now           Show atris/now.md');
+    console.log('  atris now --init    Create atris/now.md if missing');
+    console.log('  atris now --refresh Regenerate a small local now.md');
+    console.log('  atris now --all     Refresh this parent and every child Atris workspace');
+    console.log('  atris now --path    Print the file path only');
+    return;
+  }
+
+  const init = args.includes('--init');
+  const refresh = args.includes('--refresh');
+  const all = args.includes('--all');
+  const pathOnly = args.includes('--path');
+
+  let result;
+  if (all) {
+    const workspaces = findChildWorkspaces(root);
+    for (const workspace of workspaces) {
+      refreshNowFile(workspace.root);
+    }
+    result = refreshNowFile(root);
+    if (!pathOnly) {
+      console.log(`Refreshed ${workspaces.length} child workspace${workspaces.length === 1 ? '' : 's'}.`);
+      console.log('');
+    }
+  } else if (refresh) {
+    result = refreshNowFile(root);
+  } else if (init) {
+    result = ensureNowFile(root);
+  } else {
+    result = ensureNowFile(root);
+  }
+
+  const rel = path.relative(root, result.path);
+  if (pathOnly) {
+    console.log(rel);
+    return;
+  }
+
+  if (result.created) {
+    console.log(`Created ${rel}`);
+    console.log('');
+  }
+
+  const content = fs.readFileSync(result.path, 'utf8').trimEnd();
+  console.log(content);
+}
+
+module.exports = {
+  NOW_PATH,
+  ensureNowFile,
+  findChildWorkspaces,
+  nowAtris,
+  refreshNowFile,
+  renderDefaultNow,
+  renderPortfolioNow,
+};