atris 3.13.0 → 3.15.0

package/commands/computer.js

@@ -5,6 +5,7 @@
  *   atris computer --cloud          — Open CLOUD workspace mode
  *   atris computer wake             — Start the computer
  *   atris computer sleep            — Stop (files persist)
+ *   atris computer card             — Show the local computer card
  *   atris computer run <command>    — Run bash on EC2 (no LLM)
  *   atris computer grep <pattern>   — Search files on EC2
  *   atris computer ls [path]        — List files
@@ -705,8 +706,8 @@ async function runLocalBridgeOp(token, sessionId, op, timeoutSeconds = 30) {
   return data;
 }
 
-function readBusinessBinding() {
-  const bindingPath = path.join(process.cwd(), '.atris', 'business.json');
+function readBusinessBinding(cwd = process.cwd()) {
+  const bindingPath = path.join(cwd, '.atris', 'business.json');
   if (!fs.existsSync(bindingPath)) return null;
   try {
     return JSON.parse(fs.readFileSync(bindingPath, 'utf8'));
@@ -715,6 +716,160 @@ function readBusinessBinding() {
   }
 }
 
+function readPackageMeta(cwd = process.cwd()) {
+  const packagePath = path.join(cwd, 'package.json');
+  if (!fs.existsSync(packagePath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function relIfExists(cwd, target) {
+  return fs.existsSync(path.join(cwd, target)) ? target : null;
+}
+
+function detectValidationCommand(cwd = process.cwd(), pkg = null) {
+  const meta = pkg || readPackageMeta(cwd);
+  const testScript = meta?.scripts?.test;
+  if (testScript && !/no test specified/i.test(testScript)) return 'npm test';
+  if (fs.existsSync(path.join(cwd, 'pytest.ini')) || fs.existsSync(path.join(cwd, 'pyproject.toml'))) return 'pytest';
+  if (fs.existsSync(path.join(cwd, 'Cargo.toml'))) return 'cargo test';
+  if (fs.existsSync(path.join(cwd, 'go.mod'))) return 'go test ./...';
+  return 'none detected';
+}
+
+function detectComputerType(cwd = process.cwd(), pkg = null, binding = null) {
+  if (binding?.computer_type) return binding.computer_type;
+  if (binding?.workspace_type) return binding.workspace_type;
+  const meta = pkg || readPackageMeta(cwd);
+  if (meta?.bin || fs.existsSync(path.join(cwd, 'bin')) || fs.existsSync(path.join(cwd, 'commands'))) return 'codeops';
+  if (fs.existsSync(path.join(cwd, 'docs')) || fs.existsSync(path.join(cwd, 'atris', 'wiki'))) return 'research';
+  return 'workspace';
+}
+
+function buildComputerCard(cwd = process.cwd()) {
+  const binding = readBusinessBinding(cwd);
+  const pkg = readPackageMeta(cwd);
+  const folderName = path.basename(cwd);
+  const ownerName = binding?.name || pkg?.name || folderName;
+  const ownerType = binding ? 'business' : 'project';
+  const computerName = binding?.computer_name || binding?.workspace_name || `${ownerName} computer`;
+  const computerType = detectComputerType(cwd, pkg, binding);
+  const memory = [
+    relIfExists(cwd, 'atris/MAP.md'),
+    relIfExists(cwd, 'atris/TODO.md'),
+    relIfExists(cwd, 'atris/wiki'),
+    relIfExists(cwd, 'atris/logs'),
+  ].filter(Boolean);
+  const artifacts = [
+    fs.existsSync(path.join(cwd, 'atris')) ? 'atris/reports/' : null,
+    relIfExists(cwd, '.atris/receipts'),
+  ].filter(Boolean);
+
+  return {
+    ownerName,
+    ownerType,
+    computerName,
+    computerType,
+    workspace: cwd,
+    loop: 'plan -> do -> review',
+    memory,
+    validation: detectValidationCommand(cwd, pkg),
+    proof: binding ? 'atris computer proof' : 'atris proof run',
+    visual: 'atris visualize "<prompt>"',
+    artifacts,
+    generatedAt: new Date().toISOString(),
+  };
+}
+
+function renderList(items) {
+  return items.length ? items.join(', ') : 'none detected';
+}
+
+function renderComputerCard(card) {
+  return [
+    'Atris Computer Card',
+    '',
+    `  Owner:      ${card.ownerName} (${card.ownerType})`,
+    `  Computer:   ${card.computerName}`,
+    `  Type:       ${card.computerType}`,
+    `  Workspace:  ${card.workspace}`,
+    `  Loop:       ${card.loop}`,
+    `  Memory:     ${renderList(card.memory)}`,
+    `  Validate:   ${card.validation}`,
+    `  Proof:      ${card.proof}`,
+    `  Visual:     ${card.visual}`,
+    `  Artifacts:  ${renderList(card.artifacts)}`,
+  ].join('\n');
+}
+
+function renderComputerCardMarkdown(card) {
+  return [
+    '# Atris Computer Card',
+    '',
+    `Generated: ${card.generatedAt}`,
+    '',
+    `- Owner: ${card.ownerName} (${card.ownerType})`,
+    `- Computer: ${card.computerName}`,
+    `- Type: ${card.computerType}`,
+    `- Workspace: ${card.workspace}`,
+    `- Loop: ${card.loop}`,
+    `- Memory: ${renderList(card.memory)}`,
+    `- Validate: ${card.validation}`,
+    `- Proof: ${card.proof}`,
+    `- Visual: ${card.visual}`,
+    `- Artifacts: ${renderList(card.artifacts)}`,
+    '',
+  ].join('\n');
+}
+
+function parseComputerCardArgs(args = []) {
+  const options = { write: false, out: null, help: false };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--help' || arg === '-h') options.help = true;
+    else if (arg === '--write') options.write = true;
+    else if (arg === '--out' && args[i + 1]) options.out = args[++i];
+    else if (arg.startsWith('--out=')) options.out = arg.slice('--out='.length);
+  }
+  return options;
+}
+
+function defaultComputerCardPath(cwd = process.cwd()) {
+  if (fs.existsSync(path.join(cwd, 'atris'))) {
+    return path.join(cwd, 'atris', 'reports', 'computer-card.md');
+  }
+  return path.join(cwd, 'computer-card.md');
+}
+
+function computerCard(args = [], cwd = process.cwd()) {
+  const options = parseComputerCardArgs(args);
+  if (options.help) {
+    console.log('Usage: atris computer card [--write] [--out <path>]');
+    console.log('');
+    console.log('Show the local owner/computer card for this workspace.');
+    return null;
+  }
+
+  const card = buildComputerCard(cwd);
+  console.log(renderComputerCard(card));
+
+  if (options.write || options.out) {
+    const outputPath = options.out
+      ? (path.isAbsolute(options.out) ? options.out : path.join(cwd, options.out))
+      : defaultComputerCardPath(cwd);
+    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+    fs.writeFileSync(outputPath, renderComputerCardMarkdown(card), 'utf8');
+    console.log('');
+    console.log(`Wrote ${path.relative(cwd, outputPath) || outputPath}`);
+    return outputPath;
+  }
+
+  return card;
+}
+
 async function resolveBusinessContext(token) {
   const binding = readBusinessBinding();
   if (!binding) return null;
@@ -2397,6 +2552,11 @@ async function runComputer() {
     return;
   }
 
+  if (sub === 'card') {
+    computerCard(args.slice(1));
+    return;
+  }
+
   if (sub === 'claude' || sub === 'codex') {
     computerLocalLegacy(args);
     return;
@@ -2405,6 +2565,15 @@ async function runComputer() {
   if (sub === '--help') {
     console.log('Usage: atris computer [mode|command]');
     console.log('');
+    console.log('Atris computers are persistent AI workspaces for scoped jobs.');
+    console.log('');
+    console.log('  Owner = User | Business');
+    console.log('  Owner has many Computers');
+    console.log('  Computer = workspace + files + tools + secrets + memory + agents + validation');
+    console.log('');
+    console.log('Common types: codeops, research, CRM, reporting, recruiting, event ops, support, business ops.');
+    console.log('A business can be a company, lab, collective, community, artist, team, or project.');
+    console.log('');
     console.log('First use:');
     console.log('  cd ~/arena/atris-business/<business>');
     console.log('  atris computer');
@@ -2412,6 +2581,7 @@ async function runComputer() {
     console.log('');
     console.log('Modes:');
     console.log('  (default)       Choose CLOUD vs LOCAL when both are available');
+    console.log('  card            Show the local owner/computer card, no login required');
     console.log('  local           Open LOCAL Atris mode; cloud brain edits this folder');
     console.log('  proof           Run the local-edit + cloud-isolation + audit proof');
     console.log('  local-byo       Open LOCAL BYO Claude mode; Anthropic tokens, no cloud audit');
@@ -2443,6 +2613,8 @@ async function runComputer() {
     console.log('');
     console.log('Examples:');
     console.log('  atris computer');
+    console.log('  atris computer card --write');
+    console.log('  atris business init "My Lab"     # shared owner + first/default computer');
     console.log('  atris computer proof');
     console.log('  atris computer local');
     console.log('  atris computer codex');
@@ -2522,6 +2694,7 @@ async function runComputer() {
 
   switch (sub) {
     case 'chat': return computerChat(token, ctx, cloudOptions);
+    case 'card': return computerCard(args.slice(1));
     case 'proof': return computerProof(token, ctx, cloudOptions);
     case 'status': return computerStatus(token, ctx);
     case 'wake': return computerWake(token, ctx);
@@ -2544,4 +2717,9 @@ async function runComputer() {
   }
 }
 
-module.exports = { runComputer };
+module.exports = {
+  runComputer,
+  buildComputerCard,
+  renderComputerCard,
+  renderComputerCardMarkdown,
+};

package/commands/live.js

@@ -0,0 +1,289 @@
+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 readBusinessSlugFromCwd(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;
+  } catch {
+    return null;
+  }
+}
+
+function parseLiveOptions(args, cwd = process.cwd()) {
+  const first = firstPositionalArg(args);
+  return {
+    slug: first || readBusinessSlugFromCwd(cwd),
+    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(cwd),
+    cwd,
+  };
+}
+
+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,
+};

package/commands/pull.js

@@ -6,7 +6,7 @@ const { findAllMembers } = require('./member');
 const { loadConfig } = require('../utils/config');
 const { getLogPath } = require('../lib/file-ops');
 const { parseJournalSections, mergeSections, reconstructJournal } = require('../lib/journal');
-const { loadBusinesses } = require('./business');
+const { loadBusinesses, businessMatchesSlug } = require('./business');
 const { loadManifest, saveManifest, computeFileHash, buildManifest, computeLocalHashes, threeWayCompare } = require('../lib/manifest');
 const { normalizeWikiOnlyPrefix } = require('../lib/wiki');
 const { emitSyncEvent, startTimer } = require('../lib/sync-telemetry');
@@ -204,6 +204,7 @@ async function pullBusiness(slug) {
 
   // Resolve business ID — always refresh from API to avoid stale workspace_id
   let businessId, workspaceId, businessName, resolvedSlug;
+  let localSlug = slug;
   const businesses = loadBusinesses();
 
   const listResult = await apiRequestJson('/business/', { method: 'GET', token: creds.token });
@@ -220,7 +221,7 @@ async function pullBusiness(slug) {
     }
   } else {
     const match = (listResult.data || []).find(
-      b => b.slug === slug || b.name.toLowerCase() === slug.toLowerCase()
+      b => businessMatchesSlug(b, slug, { includeName: true })
     );
     if (!match) {
       console.error(`Business "${slug}" not found.`);
@@ -230,13 +231,15 @@ async function pullBusiness(slug) {
     workspaceId = match.workspace_id;
     businessName = match.name;
     resolvedSlug = match.slug;
+    localSlug = businessMatchesSlug(match, slug) ? slug : match.slug;
 
     // Update local cache
     businesses[slug] = {
       business_id: businessId,
       workspace_id: workspaceId,
       name: businessName,
-      slug: match.slug,
+      slug: localSlug,
+      canonical_slug: match.slug,
       added_at: new Date().toISOString(),
     };
     const { saveBusinesses } = require('./business');
@@ -697,7 +700,8 @@ async function pullBusiness(slug) {
   const atrisDir = path.join(outputDir, '.atris');
   fs.mkdirSync(atrisDir, { recursive: true });
   fs.writeFileSync(path.join(atrisDir, 'business.json'), JSON.stringify({
-    slug: resolvedSlug || slug,
+    slug: localSlug,
+    canonical_slug: resolvedSlug || slug,
     business_id: businessId,
     workspace_id: workspaceId,
     name: businessName,

package/commands/push.js

@@ -3,7 +3,7 @@ const path = require('path');
 const crypto = require('crypto');
 const { loadCredentials } = require('../utils/auth');
 const { apiRequestJson } = require('../utils/api');
-const { loadBusinesses, saveBusinesses } = require('./business');
+const { loadBusinesses, saveBusinesses, businessMatchesSlug } = require('./business');
 const { loadManifest, saveManifest, buildManifest, computeLocalHashes } = require('../lib/manifest');
 const { normalizeWikiOnlyPrefix } = require('../lib/wiki');
 const { emitSyncEvent, startTimer } = require('../lib/sync-telemetry');
@@ -92,7 +92,7 @@ async function pushAtris() {
   const businesses = loadBusinesses();
   const listResult = await apiRequestJson('/business/', { method: 'GET', token: creds.token });
   if (listResult.ok) {
-    const match = (listResult.data || []).find(b => b.slug === slug || b.name.toLowerCase() === slug.toLowerCase());
+    const match = (listResult.data || []).find(b => businessMatchesSlug(b, slug, { includeName: true }));
     if (!match) { console.error(`Business "${slug}" not found.`); process.exit(1); }
     businessId = match.id;
     workspaceId = match.workspace_id;