atris 2.6.0 → 2.6.2

package/commands/setup.js

@@ -0,0 +1,178 @@
+const fs = require('fs');
+const path = require('path');
+const { loadCredentials, promptUser } = require('../utils/auth');
+const { apiRequestJson } = require('../utils/api');
+
+async function setupAtris() {
+  console.log('');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('  Atris Setup');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('');
+
+  // Step 1: Check Node version
+  const nodeVersion = process.versions.node;
+  const major = parseInt(nodeVersion.split('.')[0], 10);
+  if (major < 18) {
+    console.error(`Node.js ${nodeVersion} is too old. Atris requires Node.js 18 or newer.`);
+    console.error('');
+    console.error('Update Node.js:');
+    console.error('  macOS:   brew install node');
+    console.error('  or visit https://nodejs.org/en/download');
+    process.exit(1);
+  }
+  console.log(`  [1/4] Node.js ${nodeVersion} ... OK`);
+
+  // Step 2: Check login status
+  let creds = loadCredentials();
+  if (creds && creds.token) {
+    const label = creds.email || creds.user_id || 'unknown';
+    console.log(`  [2/4] Logged in as ${label} ... OK`);
+  } else {
+    console.log('  [2/4] Not logged in. Starting login...');
+    console.log('');
+    const { loginAtris } = require('./auth');
+    // loginAtris calls process.exit, so we override it temporarily
+    const originalExit = process.exit;
+    let loginCompleted = false;
+    process.exit = (code) => {
+      if (code === 0) {
+        loginCompleted = true;
+        return; // Suppress exit on success so setup can continue
+      }
+      // On failure, actually exit
+      originalExit(code);
+    };
+    try {
+      await loginAtris();
+    } finally {
+      process.exit = originalExit;
+    }
+
+    if (!loginCompleted) {
+      console.error('\nLogin failed. Run "atris setup" again after fixing the issue.');
+      process.exit(1);
+    }
+
+    // Reload credentials after login
+    creds = loadCredentials();
+    if (!creds || !creds.token) {
+      console.error('\nLogin did not produce credentials. Run "atris login" manually, then "atris setup" again.');
+      process.exit(1);
+    }
+    console.log('');
+    console.log(`  [2/4] Logged in ... OK`);
+  }
+
+  // Step 3: Fetch businesses
+  console.log('  [3/4] Fetching your businesses...');
+  let businesses = [];
+  try {
+    const result = await apiRequestJson('/businesses/', {
+      method: 'GET',
+      token: creds.token,
+    });
+
+    if (!result.ok) {
+      console.error(`\n  Could not fetch businesses: ${result.error || 'Unknown error'}`);
+      console.error('  You can add one later with: atris business add <slug>');
+      console.log('');
+      printFinished();
+      return;
+    }
+
+    businesses = Array.isArray(result.data) ? result.data : [];
+  } catch (err) {
+    console.error(`\n  Could not fetch businesses: ${err.message || err}`);
+    console.error('  You can add one later with: atris business add <slug>');
+    console.log('');
+    printFinished();
+    return;
+  }
+
+  if (businesses.length === 0) {
+    console.log('\n  No businesses found on your account.');
+    console.log('  Create one at https://atris.ai or ask your team admin for access.');
+    console.log('');
+    printFinished();
+    return;
+  }
+
+  // Step 4: List businesses and let user pick
+  console.log('');
+  console.log('  Your businesses:');
+  businesses.forEach((b, i) => {
+    const name = b.name || b.slug || 'Unnamed';
+    const slug = b.slug || b.id || '';
+    console.log(`    ${i + 1}. ${name} (${slug})`);
+  });
+  console.log('');
+
+  const answer = await promptUser('  Which business to pull? (number or slug, or "skip"): ');
+
+  if (!answer || answer.toLowerCase() === 'skip') {
+    console.log('  Skipped. You can pull a business later with: atris pull <slug>');
+    console.log('');
+    printFinished();
+    return;
+  }
+
+  // Resolve selection — try number first, then slug match
+  let selected = null;
+  const num = parseInt(answer, 10);
+  if (!isNaN(num) && num >= 1 && num <= businesses.length) {
+    selected = businesses[num - 1];
+  } else {
+    // Try slug or name match
+    const q = answer.toLowerCase();
+    selected = businesses.find(b => (b.slug || '').toLowerCase() === q)
+      || businesses.find(b => (b.name || '').toLowerCase() === q)
+      || businesses.find(b => (b.slug || '').toLowerCase().includes(q))
+      || businesses.find(b => (b.name || '').toLowerCase().includes(q));
+  }
+
+  if (!selected) {
+    console.error(`\n  Could not find a business matching "${answer}".`);
+    console.log('  Run "atris pull <slug>" to pull manually.');
+    console.log('');
+    printFinished();
+    return;
+  }
+
+  const slug = selected.slug || selected.id;
+  console.log(`\n  [4/4] Pulling "${selected.name || slug}"...`);
+
+  try {
+    const { pullAtris } = require('./pull');
+    // Set the arg so pullAtris picks it up
+    const originalArgv = process.argv.slice();
+    process.argv[3] = slug;
+    const originalExit = process.exit;
+    process.exit = (code) => {
+      if (code === 0) return;
+      originalExit(code);
+    };
+    try {
+      await pullAtris();
+    } finally {
+      process.exit = originalExit;
+      process.argv = originalArgv;
+    }
+    console.log(`  Pulled "${selected.name || slug}" ... OK`);
+  } catch (err) {
+    console.error(`\n  Pull failed: ${err.message || err}`);
+    console.log(`  You can try again with: atris pull ${slug}`);
+  }
+
+  console.log('');
+  printFinished();
+}
+
+function printFinished() {
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('  You\'re all set! Run `atris activate` to start.');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('');
+}
+
+module.exports = { setupAtris };

package/commands/workspace-clean.js

@@ -0,0 +1,249 @@
+const { loadCredentials } = require('../utils/auth');
+const { apiRequestJson } = require('../utils/api');
+const { loadBusinesses, saveBusinesses } = require('./business');
+
+// Junk detection patterns
+const JUNK_PATTERNS = {
+  emptyFiles: (file) => (file.size || 0) <= 1,
+  versionedDuplicates: (file) => /_v\d+\.\w+$/.test(file.path),
+  actionQueues: (file) => /action_queue\.json$/.test(file.path),
+  agentOutputDumps: (file) => /^\/?(agents\/[^/]+\/output\/)/.test(file.path),
+  researchDumps: (file) => /^\/?(agents\/[^/]+\/research\/)/.test(file.path),
+};
+
+const JUNK_LABELS = {
+  emptyFiles: 'Empty files (size <= 1 byte)',
+  versionedDuplicates: 'Versioned duplicates (*_v1, *_v2, etc.)',
+  actionQueues: 'Action queue files',
+  agentOutputDumps: 'Agent output dumps (agents/*/output/)',
+  researchDumps: 'Research dumps (agents/*/research/)',
+};
+
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 B';
+  const units = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  return `${(bytes / Math.pow(1024, i)).toFixed(i > 0 ? 1 : 0)} ${units[i]}`;
+}
+
+async function cleanWorkspace() {
+  const slug = process.argv[3];
+  const autoConfirm = process.argv.includes('--yes');
+
+  if (!slug || slug === '--help') {
+    console.log('');
+    console.log('Usage: atris clean-workspace <business-slug> [--yes]');
+    console.log('');
+    console.log('Analyzes a workspace for junk files and shows a cleanup report.');
+    console.log('Pass --yes to actually delete the detected junk.');
+    console.log('');
+    console.log('Detects:');
+    console.log('  - Empty files (0-1 bytes)');
+    console.log('  - Versioned duplicates (*_v1.md, *_v2.md, etc.)');
+    console.log('  - action_queue.json files');
+    console.log('  - Agent output dumps (agents/*/output/)');
+    console.log('  - Research dumps (agents/*/research/)');
+    console.log('');
+    return;
+  }
+
+  // Auth
+  const creds = loadCredentials();
+  if (!creds || !creds.token) {
+    console.error('Not logged in. Run: atris login');
+    process.exit(1);
+  }
+
+  // Resolve business
+  let businessId, workspaceId, businessName;
+  const businesses = loadBusinesses();
+
+  if (businesses[slug]) {
+    businessId = businesses[slug].business_id;
+    workspaceId = businesses[slug].workspace_id;
+    businessName = businesses[slug].name || slug;
+  } else {
+    const listResult = await apiRequestJson('/businesses/', { method: 'GET', token: creds.token });
+    if (!listResult.ok) {
+      console.error(`Failed to fetch businesses: ${listResult.error || listResult.status}`);
+      process.exit(1);
+    }
+    const match = (listResult.data || []).find(
+      b => b.slug === slug || b.name.toLowerCase() === slug.toLowerCase()
+    );
+    if (!match) {
+      console.error(`Business "${slug}" not found.`);
+      process.exit(1);
+    }
+    businessId = match.id;
+    workspaceId = match.workspace_id;
+    businessName = match.name;
+
+    // Cache for next time
+    businesses[slug] = {
+      business_id: businessId,
+      workspace_id: workspaceId,
+      name: businessName,
+      slug: match.slug,
+      added_at: new Date().toISOString(),
+    };
+    saveBusinesses(businesses);
+  }
+
+  if (!workspaceId) {
+    console.error(`Business "${slug}" has no workspace.`);
+    process.exit(1);
+  }
+
+  // Fetch snapshot (metadata only)
+  console.log('');
+  console.log(`Scanning ${businessName}...`);
+
+  const result = await apiRequestJson(
+    `/businesses/${businessId}/workspaces/${workspaceId}/snapshot?include_content=false`,
+    { method: 'GET', token: creds.token, timeoutMs: 60000 }
+  );
+
+  if (!result.ok) {
+    const msg = result.error || `HTTP ${result.status}`;
+    if (result.status === 409) {
+      console.error('\n  Computer is sleeping. Wake it first.');
+    } else if (result.status === 403) {
+      console.error(`\n  Access denied for "${slug}".`);
+    } else if (result.status === 404) {
+      console.error(`\n  Business "${slug}" not found.`);
+    } else {
+      console.error(`\n  Failed: ${msg}`);
+    }
+    process.exit(1);
+  }
+
+  const files = result.data.files || [];
+  if (files.length === 0) {
+    console.log('  Workspace is empty. Nothing to clean.');
+    return;
+  }
+
+  // Analyze workspace
+  const totalSize = files.reduce((sum, f) => sum + (f.size || 0), 0);
+
+  // Directory breakdown
+  const dirStats = {};
+  for (const file of files) {
+    const p = (file.path || '').replace(/^\//, '');
+    const topDir = p.includes('/') ? p.split('/')[0] : '(root)';
+    if (!dirStats[topDir]) dirStats[topDir] = { count: 0, size: 0 };
+    dirStats[topDir].count++;
+    dirStats[topDir].size += file.size || 0;
+  }
+
+  // Detect junk
+  const junkByCategory = {};
+  const allJunkPaths = new Set();
+
+  for (const [key, testFn] of Object.entries(JUNK_PATTERNS)) {
+    const matches = files.filter(testFn);
+    if (matches.length > 0) {
+      junkByCategory[key] = matches;
+      for (const m of matches) allJunkPaths.add(m.path);
+    }
+  }
+
+  const junkSize = files
+    .filter(f => allJunkPaths.has(f.path))
+    .reduce((sum, f) => sum + (f.size || 0), 0);
+
+  // Print report
+  console.log('');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log(`  Workspace: ${businessName}`);
+  console.log(`  Total files: ${files.length}    Total size: ${formatBytes(totalSize)}`);
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+
+  // Directory breakdown
+  console.log('');
+  console.log('  Files by directory:');
+  const sortedDirs = Object.entries(dirStats).sort((a, b) => b[1].size - a[1].size);
+  for (const [dir, stats] of sortedDirs) {
+    const pct = totalSize > 0 ? ((stats.size / totalSize) * 100).toFixed(0) : 0;
+    console.log(`    ${dir.padEnd(30)} ${String(stats.count).padStart(5)} files  ${formatBytes(stats.size).padStart(10)}  (${pct}%)`);
+  }
+
+  // Junk report
+  console.log('');
+  if (allJunkPaths.size === 0) {
+    console.log('  No junk detected. Workspace is clean.');
+    console.log('');
+    return;
+  }
+
+  console.log('  Junk detected:');
+  console.log('');
+
+  for (const [key, matches] of Object.entries(junkByCategory)) {
+    const catSize = matches.reduce((sum, f) => sum + (f.size || 0), 0);
+    console.log(`    ${JUNK_LABELS[key]}  (${matches.length} files, ${formatBytes(catSize)})`);
+
+    // Show up to 10 example paths
+    const show = matches.slice(0, 10);
+    for (const f of show) {
+      console.log(`      - ${(f.path || '').replace(/^\//, '')}  (${formatBytes(f.size || 0)})`);
+    }
+    if (matches.length > 10) {
+      console.log(`      ... and ${matches.length - 10} more`);
+    }
+    console.log('');
+  }
+
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log(`  Would remove: ${allJunkPaths.size} files (${formatBytes(junkSize)})`);
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('');
+
+  if (!autoConfirm) {
+    console.log('  Run with --yes to clean up:');
+    console.log(`    atris clean-workspace ${slug} --yes`);
+    console.log('');
+    return;
+  }
+
+  // Delete junk by syncing empty content
+  console.log('  Cleaning...');
+
+  const filesToDelete = Array.from(allJunkPaths).map(p => ({ path: p, content: '' }));
+
+  // Batch in chunks of 50 to avoid huge payloads
+  const BATCH_SIZE = 50;
+  let deleted = 0;
+
+  for (let i = 0; i < filesToDelete.length; i += BATCH_SIZE) {
+    const batch = filesToDelete.slice(i, i + BATCH_SIZE);
+
+    const syncResult = await apiRequestJson(
+      `/businesses/${businessId}/workspaces/${workspaceId}/sync`,
+      {
+        method: 'POST',
+        token: creds.token,
+        body: { files: batch },
+        headers: { 'X-Atris-Actor-Source': 'cli' },
+      }
+    );
+
+    if (!syncResult.ok) {
+      const msg = syncResult.error || `HTTP ${syncResult.status}`;
+      console.error(`\n  Cleanup failed at batch ${Math.floor(i / BATCH_SIZE) + 1}: ${msg}`);
+      process.exit(1);
+    }
+
+    deleted += batch.length;
+    if (filesToDelete.length > BATCH_SIZE) {
+      console.log(`    ${deleted}/${filesToDelete.length} files processed...`);
+    }
+  }
+
+  console.log('');
+  console.log(`  Done. Removed ${deleted} junk files (${formatBytes(junkSize)}).`);
+  console.log('');
+}
+
+module.exports = { cleanWorkspace };

package/lib/manifest.js

@@ -0,0 +1,224 @@
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { computeContentHash } = require('./journal');
+
+/**
+ * Get the manifest file path for a business slug.
+ * Stored at ~/.atris/businesses/{slug}/manifest.json
+ */
+function getManifestPath(slug) {
+  return path.join(os.homedir(), '.atris', 'businesses', slug, 'manifest.json');
+}
+
+/**
+ * Load the manifest for a business, or null if no previous sync.
+ */
+function loadManifest(slug) {
+  const p = getManifestPath(slug);
+  if (!fs.existsSync(p)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Save a manifest after a successful sync.
+ */
+function saveManifest(slug, manifest) {
+  const p = getManifestPath(slug);
+  const dir = path.dirname(p);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(p, JSON.stringify(manifest, null, 2));
+}
+
+/**
+ * Compute SHA-256 hash of normalized content.
+ * Delegates to journal.js computeContentHash.
+ */
+function computeFileHash(content) {
+  return computeContentHash(content);
+}
+
+/**
+ * Build a manifest object from a set of files.
+ * files: { [path]: { hash, size } }
+ */
+function buildManifest(files, commitHash) {
+  return {
+    last_sync: new Date().toISOString(),
+    last_commit: commitHash || null,
+    files,
+  };
+}
+
+/**
+ * Walk a local directory and compute hashes for all text files.
+ * Returns: { "/path": { hash, size } }
+ */
+const SKIP_DIRS = new Set([
+  'node_modules', '__pycache__', '.git', 'venv', '.venv',
+  'lost+found', '.cache', '.atris',
+]);
+
+function computeLocalHashes(localDir) {
+  const files = {};
+
+  function walk(dir) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith('.')) continue;
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name)) continue;
+        walk(fullPath);
+      } else if (entry.isFile()) {
+        const relPath = '/' + path.relative(localDir, fullPath);
+        try {
+          // Hash raw bytes to match warm runner's _hash_bytes(data)
+          const rawBytes = fs.readFileSync(fullPath);
+          const hash = crypto.createHash('sha256').update(rawBytes).digest('hex');
+          files[relPath] = { hash, size: rawBytes.length };
+        } catch {
+          // skip binary or unreadable
+        }
+      }
+    }
+  }
+
+  walk(localDir);
+  return files;
+}
+
+/**
+ * Three-way comparison between local files, remote files, and the last-synced manifest.
+ *
+ * localFiles:  { "/path": { hash, size } }
+ * remoteFiles: { "/path": { hash, size } }
+ * manifest:    { files: { "/path": { hash, size } } } or null (first sync)
+ *
+ * Returns: { toPull, toPush, conflicts, unchanged, deletedLocal, deletedRemote, newLocal, newRemote }
+ * Each array contains file path strings.
+ */
+function threeWayCompare(localFiles, remoteFiles, manifest) {
+  const result = {
+    toPull: [],
+    toPush: [],
+    conflicts: [],
+    unchanged: [],
+    deletedLocal: [],
+    deletedRemote: [],
+    newLocal: [],
+    newRemote: [],
+  };
+
+  // First sync — no manifest
+  if (!manifest || !manifest.files) {
+    // Everything remote is "new from remote"
+    for (const p of Object.keys(remoteFiles)) {
+      if (localFiles[p] && localFiles[p].hash === remoteFiles[p].hash) {
+        result.unchanged.push(p);
+      } else if (localFiles[p]) {
+        // Both exist with different hashes, no baseline — treat as conflict
+        result.conflicts.push(p);
+      } else {
+        result.newRemote.push(p);
+      }
+    }
+    // Local files not in remote are new local
+    for (const p of Object.keys(localFiles)) {
+      if (!remoteFiles[p]) {
+        result.newLocal.push(p);
+      }
+    }
+    return result;
+  }
+
+  const base = manifest.files;
+  const allPaths = new Set([
+    ...Object.keys(localFiles),
+    ...Object.keys(remoteFiles),
+    ...Object.keys(base),
+  ]);
+
+  for (const p of allPaths) {
+    const inLocal = p in localFiles;
+    const inRemote = p in remoteFiles;
+    const inBase = p in base;
+
+    const localHash = inLocal ? localFiles[p].hash : null;
+    const remoteHash = inRemote ? remoteFiles[p].hash : null;
+    const baseHash = inBase ? base[p].hash : null;
+
+    if (inLocal && inRemote && inBase) {
+      // All three exist — standard three-way
+      const localChanged = localHash !== baseHash;
+      const remoteChanged = remoteHash !== baseHash;
+
+      if (!localChanged && !remoteChanged) {
+        result.unchanged.push(p);
+      } else if (!localChanged && remoteChanged) {
+        result.toPull.push(p);
+      } else if (localChanged && !remoteChanged) {
+        result.toPush.push(p);
+      } else {
+        // Both changed
+        if (localHash === remoteHash) {
+          // Both changed to the same thing
+          result.unchanged.push(p);
+        } else {
+          result.conflicts.push(p);
+        }
+      }
+    } else if (inRemote && !inBase && !inLocal) {
+      // New on remote
+      result.newRemote.push(p);
+    } else if (inLocal && !inBase && !inRemote) {
+      // New locally
+      result.newLocal.push(p);
+    } else if (inBase && !inRemote && inLocal) {
+      // Was in base, deleted on remote, still local
+      result.deletedRemote.push(p);
+    } else if (inBase && !inLocal && inRemote) {
+      // Was in base, deleted locally, still remote
+      result.deletedLocal.push(p);
+    } else if (inBase && !inLocal && !inRemote) {
+      // Deleted on both sides — nothing to do
+      // (don't add to any list)
+    } else if (inLocal && inRemote && !inBase) {
+      // Both sides have it but no base — new on both
+      if (localHash === remoteHash) {
+        result.unchanged.push(p);
+      } else {
+        result.conflicts.push(p);
+      }
+    } else if (inRemote && inBase && !inLocal) {
+      // Deleted locally but remote still has it (and maybe changed)
+      result.deletedLocal.push(p);
+    } else if (inLocal && inBase && !inRemote) {
+      // Deleted on remote but local still has it (and maybe changed)
+      result.deletedRemote.push(p);
+    }
+  }
+
+  return result;
+}
+
+module.exports = {
+  loadManifest,
+  saveManifest,
+  computeFileHash,
+  buildManifest,
+  computeLocalHashes,
+  threeWayCompare,
+  getManifestPath,
+  SKIP_DIRS,
+};