atris 2.5.5 → 2.6.1

package/commands/push.js

@@ -3,21 +3,29 @@ const path = require('path');
 const { loadCredentials } = require('../utils/auth');
 const { apiRequestJson } = require('../utils/api');
 const { loadBusinesses, saveBusinesses } = require('./business');
+const { loadManifest, saveManifest, computeFileHash, buildManifest, computeLocalHashes, threeWayCompare, SKIP_DIRS } = require('../lib/manifest');
 
 async function pushAtris() {
   const slug = process.argv[3];
 
   if (!slug || slug === '--help') {
-    console.log('Usage: atris push <business-slug> [--from <path>]');
+    console.log('Usage: atris push <business-slug> [--from <path>] [--force]');
     console.log('');
     console.log('Push local files to a Business Computer.');
     console.log('');
+    console.log('Options:');
+    console.log('  --from <path>   Push from a custom directory');
+    console.log('  --force         Push everything, overwrite conflicts');
+    console.log('');
     console.log('Examples:');
     console.log('  atris push pallet                    Push from atris/pallet/ or ./pallet/');
     console.log('  atris push pallet --from ./my-dir/   Push from a custom directory');
+    console.log('  atris push pallet --force             Override conflicts');
     process.exit(0);
   }
 
+  const force = process.argv.includes('--force');
+
   const creds = loadCredentials();
   if (!creds || !creds.token) {
     console.error('Not logged in. Run: atris login');
@@ -50,15 +58,15 @@ async function pushAtris() {
   }
 
   // Resolve business ID
-  let businessId, workspaceId, businessName;
+  let businessId, workspaceId, businessName, resolvedSlug;
   const businesses = loadBusinesses();
 
   if (businesses[slug]) {
     businessId = businesses[slug].business_id;
     workspaceId = businesses[slug].workspace_id;
     businessName = businesses[slug].name || slug;
+    resolvedSlug = businesses[slug].slug || slug;
   } else {
-    // Try to find by slug via API
     const listResult = await apiRequestJson('/businesses/', { method: 'GET', token: creds.token });
     if (!listResult.ok) {
       console.error(`Failed to fetch businesses: ${listResult.errorMessage || listResult.status}`);
@@ -74,8 +82,8 @@ async function pushAtris() {
     businessId = match.id;
     workspaceId = match.workspace_id;
     businessName = match.name;
+    resolvedSlug = match.slug;
 
-    // Auto-save
     businesses[slug] = {
       business_id: businessId,
       workspace_id: workspaceId,
@@ -91,80 +99,161 @@ async function pushAtris() {
     process.exit(1);
   }
 
-  // Walk local directory and collect files
-  const files = [];
-  const SKIP_DIRS = new Set(['node_modules', '__pycache__', '.git', 'venv', '.venv', 'lost+found', '.cache']);
-
-  function walkDir(dir) {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    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;
-        walkDir(fullPath);
-      } else if (entry.isFile()) {
-        const relPath = '/' + path.relative(sourceDir, fullPath);
-        try {
-          const content = fs.readFileSync(fullPath, 'utf8');
-          files.push({ path: relPath, content });
-        } catch {
-          // Skip binary files
-        }
-      }
-    }
-  }
+  // Load manifest (last sync state)
+  const manifest = loadManifest(resolvedSlug || slug);
 
-  walkDir(sourceDir);
+  // Compute local file hashes
+  const localFiles = computeLocalHashes(sourceDir);
 
-  if (files.length === 0) {
+  if (Object.keys(localFiles).length === 0) {
     console.log(`\nNo files to push from ${sourceDir}`);
     return;
   }
 
+  // Get remote snapshot for three-way compare
   console.log('');
-  console.log(`Pushing ${files.length} files to ${businessName}...`);
-
-  // Sync — one API call pushes everything
-  const result = await apiRequestJson(
-    `/businesses/${businessId}/workspaces/${workspaceId}/sync`,
-    {
-      method: 'POST',
-      token: creds.token,
-      body: { files },
-    }
+  console.log(`Pushing to ${businessName}...`);
+
+  const snapshotResult = await apiRequestJson(
+    `/businesses/${businessId}/workspaces/${workspaceId}/snapshot?include_content=false`,
+    { method: 'GET', token: creds.token }
   );
 
-  if (!result.ok) {
-    const msg = result.errorMessage || `HTTP ${result.status}`;
-    if (result.status === 409) {
-      console.error(`\nComputer is sleeping. Wake it first, then push.`);
-    } else if (result.status === 403) {
-      console.error(`\nAccess denied: ${msg}`);
-    } else {
-      console.error(`\nPush failed: ${msg}`);
+  let remoteFiles = {};
+  if (snapshotResult.ok && snapshotResult.data && snapshotResult.data.files) {
+    for (const file of snapshotResult.data.files) {
+      if (file.path && !file.binary) {
+        remoteFiles[file.path] = { hash: file.hash, size: file.size || 0 };
+      }
     }
-    process.exit(1);
   }
 
-  const data = result.data;
-  console.log('');
-  if (data.written > 0) {
-    console.log(`  ${data.written} file${data.written > 1 ? 's' : ''} written`);
+  // Three-way compare
+  const diff = threeWayCompare(localFiles, remoteFiles, manifest);
+
+  // Determine what to push
+  const filesToPush = [];
+
+  // Files we changed that remote didn't
+  for (const p of [...diff.toPush, ...diff.newLocal]) {
+    const localPath = path.join(sourceDir, p.replace(/^\//, ''));
+    try {
+      const content = fs.readFileSync(localPath, 'utf8');
+      filesToPush.push({ path: p, content });
+    } catch {
+      // skip
+    }
+  }
+
+  // Force mode: also push conflicts
+  const conflictPaths = [];
+  if (force) {
+    for (const p of diff.conflicts) {
+      const localPath = path.join(sourceDir, p.replace(/^\//, ''));
+      try {
+        const content = fs.readFileSync(localPath, 'utf8');
+        filesToPush.push({ path: p, content });
+      } catch {
+        // skip
+      }
+    }
+  } else {
+    for (const p of diff.conflicts) {
+      conflictPaths.push(p);
+    }
   }
-  if (data.unchanged > 0) {
-    console.log(`  ${data.unchanged} unchanged`);
+
+  console.log('');
+
+  if (filesToPush.length === 0 && conflictPaths.length === 0) {
+    console.log('  Already up to date.');
+    console.log('');
+    return;
   }
-  if (data.errors > 0) {
-    console.log(`  ${data.errors} error${data.errors > 1 ? 's' : ''}`);
-    for (const r of (data.results || [])) {
-      if (r.status === 'error') {
-        console.log(`    ${r.path}: ${r.error}`);
+
+  // Push the files
+  let pushed = 0;
+  if (filesToPush.length > 0) {
+    const result = await apiRequestJson(
+      `/businesses/${businessId}/workspaces/${workspaceId}/sync`,
+      {
+        method: 'POST',
+        token: creds.token,
+        body: { files: filesToPush },
+        headers: { 'X-Atris-Actor-Source': 'cli' },
+      }
+    );
+
+    if (!result.ok) {
+      const msg = result.errorMessage || `HTTP ${result.status}`;
+      if (result.status === 409) {
+        console.error(`  Computer is sleeping. Wake it first, then push.`);
+      } else if (result.status === 403) {
+        console.error(`  Access denied: ${msg}`);
+      } else {
+        console.error(`  Push failed: ${msg}`);
+      }
+      process.exit(1);
+    }
+
+    // Display results
+    for (const p of diff.toPush) {
+      console.log(`  \u2191 ${p.replace(/^\//, '')}  pushing your changes`);
+      pushed++;
+    }
+    for (const p of diff.newLocal) {
+      console.log(`  + ${p.replace(/^\//, '')}  new file`);
+      pushed++;
+    }
+    if (force) {
+      for (const p of diff.conflicts) {
+        console.log(`  ! ${p.replace(/^\//, '')}  overwritten (--force)`);
+        pushed++;
       }
     }
   }
-  console.log(`\n  Synced to ${businessName}.`);
+
+  // Show conflicts
+  for (const p of conflictPaths) {
+    console.log(`  \u26A0 ${p.replace(/^\//, '')}  CONFLICT \u2014 skipped (use --force to override)`);
+  }
+
+  // Show unchanged
+  if (diff.unchanged.length > 0) {
+    // Don't list them all, just count
+  }
+
+  // Summary
+  console.log('');
+  const parts = [];
+  if (pushed > 0) parts.push(`${pushed} pushed`);
+  if (diff.unchanged.length > 0) parts.push(`${diff.unchanged.length} unchanged`);
+  if (conflictPaths.length > 0) parts.push(`${conflictPaths.length} conflict${conflictPaths.length > 1 ? 's' : ''}`);
+  if (parts.length > 0) console.log(`  ${parts.join(', ')}.`);
+
+  // Get commit hash after push
+  let commitHash = null;
+  try {
+    const headResult = await apiRequestJson(
+      `/businesses/${businessId}/workspaces/${workspaceId}/git/head`,
+      { method: 'GET', token: creds.token }
+    );
+    if (headResult.ok && headResult.data && headResult.data.commit) {
+      commitHash = headResult.data.commit;
+    }
+  } catch {
+    // Git might not be initialized yet
+  }
+
+  // Update manifest with new state (merge local + remote)
+  const mergedFiles = { ...remoteFiles };
+  for (const p of Object.keys(localFiles)) {
+    if (filesToPush.some(f => f.path === p)) {
+      mergedFiles[p] = localFiles[p]; // we pushed this, so our hash is now the truth
+    }
+  }
+  const newManifest = buildManifest(mergedFiles, commitHash);
+  saveManifest(resolvedSlug || slug, newManifest);
 }
 
 module.exports = { pushAtris };

package/lib/manifest.js

@@ -0,0 +1,222 @@
+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 {
+          const content = fs.readFileSync(fullPath, 'utf8');
+          const hash = computeFileHash(content);
+          files[relPath] = { hash, size: Buffer.byteLength(content) };
+        } 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,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "2.5.5",
+  "version": "2.6.1",
   "description": "atrisDev (atris dev) - CLI for AI coding agents. Works with Claude Code, Cursor, Windsurf. Make any codebase AI-navigable.",
   "main": "bin/atris.js",
   "bin": {
@@ -12,7 +12,6 @@
     "utils/",
     "lib/",
     "README.md",
-    "AGENT.md",
     "AGENTS.md",
     "atris.md",
     "GETTING_STARTED.md",
@@ -20,8 +19,14 @@
     "atris/atrisDev.md",
     "atris/CLAUDE.md",
     "atris/GEMINI.md",
-    "atris/team/",
-    "atris/experiments/",
+    "atris/GETTING_STARTED.md",
+    "atris/team/navigator/MEMBER.md",
+    "atris/team/executor/MEMBER.md",
+    "atris/team/validator/MEMBER.md",
+    "atris/team/brainstormer/MEMBER.md",
+    "atris/team/launcher/MEMBER.md",
+    "atris/team/researcher/MEMBER.md",
+    "atris/team/_template/MEMBER.md",
     "atris/features/_templates/",
     "atris/policies/",
     "atris/skills/"

package/utils/auth.js

@@ -124,6 +124,101 @@ function getCredentialsPath() {
   return path.join(getAtrisDir(), 'credentials.json');
 }
 
+function getSessionsDir() {
+  const dir = path.join(getAtrisDir(), 'sessions');
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+
+function getTerminalSessionId() {
+  // Unique per terminal window/tab — works across macOS terminals, tmux, VS Code, Ghostty
+  const envId = process.env.TERM_SESSION_ID     // macOS Terminal.app
+    || process.env.ITERM_SESSION_ID              // iTerm2
+    || process.env.TMUX_PANE                     // tmux pane
+    || process.env.WT_SESSION                    // Windows Terminal
+    || process.env.WEZTERM_PANE;                 // WezTerm
+  if (envId) return envId;
+
+  // Universal fallback: TTY device name (unique per terminal tab on macOS/Linux)
+  // Each Ghostty/iTerm/Terminal tab gets a unique /dev/ttysNNN
+  try {
+    // Method 1: check if stdin is a TTY and resolve its path
+    if (process.stdin.isTTY) {
+      const resolved = fs.realpathSync('/dev/stdin');
+      if (resolved && resolved.startsWith('/dev/tty')) return resolved;
+    }
+  } catch {}
+
+  try {
+    // Method 2: shell out to tty command
+    const { execSync } = require('child_process');
+    const tty = execSync('tty', { encoding: 'utf8', stdio: ['inherit', 'pipe', 'pipe'] }).trim();
+    if (tty && tty !== 'not a tty' && tty.startsWith('/dev/')) return tty;
+  } catch {}
+
+  return null;
+}
+
+function sanitizeSessionId(id) {
+  // Make filesystem-safe: replace non-alphanumeric with dashes, truncate
+  return id.replace(/[^a-zA-Z0-9_-]/g, '-').slice(0, 64);
+}
+
+function getSessionFilePath() {
+  const sessionId = getTerminalSessionId();
+  if (!sessionId) return null;
+  return path.join(getSessionsDir(), `${sanitizeSessionId(sessionId)}.json`);
+}
+
+function setSessionProfile(profileName) {
+  const sessionPath = getSessionFilePath();
+  if (!sessionPath) {
+    // No terminal session ID — fall back to global switch
+    return false;
+  }
+  fs.writeFileSync(sessionPath, JSON.stringify({
+    profile: profileName,
+    set_at: new Date().toISOString(),
+  }));
+  return true;
+}
+
+function getSessionProfile() {
+  const sessionPath = getSessionFilePath();
+  if (!sessionPath || !fs.existsSync(sessionPath)) return null;
+  try {
+    const data = JSON.parse(fs.readFileSync(sessionPath, 'utf8'));
+    return data.profile || null;
+  } catch {
+    return null;
+  }
+}
+
+function clearSessionProfile() {
+  const sessionPath = getSessionFilePath();
+  if (sessionPath && fs.existsSync(sessionPath)) {
+    fs.unlinkSync(sessionPath);
+  }
+}
+
+function cleanStaleSessions() {
+  // Remove session files older than 7 days
+  const dir = path.join(getAtrisDir(), 'sessions');
+  if (!fs.existsSync(dir)) return;
+  const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1000;
+  try {
+    for (const f of fs.readdirSync(dir)) {
+      const fp = path.join(dir, f);
+      try {
+        const stat = fs.statSync(fp);
+        if (stat.mtimeMs < cutoff) fs.unlinkSync(fp);
+      } catch {}
+    }
+  } catch {}
+}
+
 function getProfilesDir() {
   const dir = path.join(getAtrisDir(), 'profiles');
   if (!fs.existsSync(dir)) {
@@ -205,6 +300,32 @@ function saveCredentials(token, refreshToken, email, userId, provider) {
 }
 
 function loadCredentials() {
+  // Priority: ATRIS_PROFILE env var → per-terminal session file → global credentials.json
+
+  // 1. Explicit env var override
+  const profileOverride = process.env.ATRIS_PROFILE;
+  if (profileOverride) {
+    const profile = loadProfile(profileOverride);
+    if (profile) return profile;
+    const profiles = listProfiles();
+    const q = profileOverride.toLowerCase();
+    const match = profiles.find(p => p.toLowerCase() === q)
+      || profiles.find(p => p.toLowerCase().startsWith(q))
+      || profiles.find(p => p.toLowerCase().includes(q));
+    if (match) {
+      const matched = loadProfile(match);
+      if (matched) return matched;
+    }
+  }
+
+  // 2. Per-terminal session override (set by atris switch)
+  const sessionProfile = getSessionProfile();
+  if (sessionProfile) {
+    const profile = loadProfile(sessionProfile);
+    if (profile) return profile;
+  }
+
+  // 3. Global credentials.json
   const credentialsPath = getCredentialsPath();
 
   if (!fs.existsSync(credentialsPath)) {
@@ -456,4 +577,10 @@ module.exports = {
   deleteProfile,
   profileNameFromEmail,
   autoSaveProfile,
+  // Per-terminal sessions
+  getTerminalSessionId,
+  setSessionProfile,
+  getSessionProfile,
+  clearSessionProfile,
+  cleanStaleSessions,
 };