atris 2.5.3 → 2.5.4

package/bin/atris.js

@@ -164,6 +164,14 @@ function searchJournal(keyword) {
 }
 
 function consoleCmd() {
+  const extractedCommand = path.join(__dirname, '..', 'commands', 'console.js');
+  if (fs.existsSync(extractedCommand)) {
+    const loaded = require('../commands/console');
+    if (loaded && typeof loaded.consoleCommand === 'function') {
+      return loaded.consoleCommand();
+    }
+  }
+
   const workspace = process.cwd();
   const daemonScript = path.join(workspace, 'cli', 'atrisd.sh');
 
@@ -211,11 +219,12 @@ function showHelp() {
   console.log('  plan       - Create build spec with visualization');
   console.log('  do         - Execute tasks');
   console.log('  review     - Validate work (tests, safety checks, docs)');
+  console.log('  run        - Auto-chain plan→do→review (autonomous loop, auto-pushes)');
   console.log('');
   console.log('Context & tracking:');
   console.log('  log        - Add ideas to inbox');
   console.log('  activate   - Load Atris context');
-  console.log('  status     - See active work and completions');
+  console.log('  status     - See active work and completions (--json for machine output)');
   console.log('  analytics  - Show recent productivity from journals');
   console.log('  search     - Search journal history (atris search <keyword>)');
   console.log('  clean      - Housekeeping (stale tasks, archive journals, broken refs)');
@@ -226,10 +235,18 @@ function showHelp() {
   console.log('  autopilot  - Guided loop that can clarify TODOs and run plan → do → review');
   console.log('  visualize  - Legacy visualization helper (prefer "atris plan")');
   console.log('');
+  console.log('Experiments:');
+  console.log('  experiments init [slug]     - Prepare atris/experiments/ or scaffold a pack');
+  console.log('  experiments validate        - Validate experiment packs');
+  console.log('  experiments benchmark [m]   - Run validate/runtime experiment benchmarks');
+  console.log('');
   console.log('Quick commands:');
   console.log('  atris      - Load context and start (natural language)');
   console.log('  next       - Auto-advance to next step');
   console.log('');
+  console.log('Sync:');
+  console.log('  pull       - Pull journals + member data from cloud');
+  console.log('');
   console.log('Cloud & agents:');
   console.log('  console    - Start/attach always-on coding console (tmux daemon)');
   console.log('  agent      - Select which Atris agent to use');
@@ -366,9 +383,9 @@ const { planAtris: planCmd, doAtris: doCmd, reviewAtris: reviewCmd } = require('
 // All other commands are lazy-loaded inline (require() only when invoked)
 
 // Check if this is a known command or natural language input
-const knownCommands = ['init', 'log', 'status', 'analytics', 'visualize', 'brainstorm', 'autopilot', 'plan', 'do', 'review',
+const knownCommands = ['init', 'log', 'status', 'analytics', 'visualize', 'brainstorm', 'autopilot', 'run', 'plan', 'do', 'review',
                        'activate', 'agent', 'chat', 'console', 'login', 'logout', 'whoami', 'switch', 'accounts', 'update', 'upgrade', 'version', 'help', 'next', 'atris',
-                       'clean', 'verify', 'search', 'skill', 'member', 'plugin', 'sync',
+                       'clean', 'verify', 'search', 'skill', 'member', 'plugin', 'experiments', 'pull', 'sync',
                        'gmail', 'calendar', 'twitter', 'slack', 'integrations'];
 
 // Check if command is an atris.md spec file - triggers welcome visualization
@@ -715,6 +732,42 @@ if (command === 'init') {
   console.log('   Prefer: atris plan');
   console.log('');
   require('../commands/visualize').visualizeAtris();
+} else if (command === 'run') {
+  const args = process.argv.slice(3);
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log('');
+    console.log('Usage: atris run [options]');
+    console.log('');
+    console.log('Auto-chain plan → do → review cycles autonomously.');
+    console.log('Reads inbox ideas, creates tasks, builds them, validates, repeats.');
+    console.log('');
+    console.log('Options:');
+    console.log('  --cycles=N    Max cycles (default: 5)');
+    console.log('  --once        Single plan→do→review cycle');
+    console.log('  --verbose     Show claude -p output');
+    console.log('  --dry-run     Preview without executing');
+    console.log('  --timeout=N   Phase timeout in seconds (default: 600)');
+    console.log('  --push        Auto-push after each cycle (default: true)');
+    console.log('  --no-push     Skip auto-push after each cycle');
+    console.log('');
+    process.exit(0);
+  }
+
+  const verbose = args.includes('--verbose') || args.includes('-v');
+  const dryRun = args.includes('--dry-run');
+  const once = args.includes('--once');
+  const push = !args.includes('--no-push');
+  const cyclesArg = args.find(a => a.startsWith('--cycles='));
+  const maxCycles = cyclesArg ? parseInt(cyclesArg.split('=')[1]) : 5;
+  const timeoutArg = args.find(a => a.startsWith('--timeout='));
+  const timeout = timeoutArg ? parseInt(timeoutArg.split('=')[1]) * 1000 : undefined;
+
+  require('../commands/run').runAtris({ maxCycles, verbose, dryRun, once, push, timeout })
+    .then(() => process.exit(0))
+    .catch((error) => {
+      console.error(`\u2717 Run failed: ${error.message || error}`);
+      process.exit(1);
+    });
 } else if (command === 'autopilot') {
   const args = process.argv.slice(3);
   if (args.includes('--help') || args.includes('-h')) {
@@ -813,7 +866,8 @@ if (command === 'init') {
     });
 } else if (command === 'status') {
   const isQuick = process.argv.includes('--quick') || process.argv.includes('-q');
-  statusCmd(isQuick);
+  const isJson = process.argv.includes('--json');
+  statusCmd(isQuick, isJson);
 } else if (command === 'analytics') {
   require('../commands/analytics').analyticsAtris();
 } else if (command === 'clean') {
@@ -866,10 +920,28 @@ if (command === 'init') {
   const subcommand = process.argv[3];
   const args = process.argv.slice(4);
   require('../commands/member').memberCommand(subcommand, ...args);
+} else if (command === 'pull') {
+  require('../commands/pull').pullAtris()
+    .then(() => process.exit(0))
+    .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
+} else if (command === 'push') {
+  require('../commands/push').pushAtris()
+    .then(() => process.exit(0))
+    .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
+} else if (command === 'business') {
+  const subcommand = process.argv[3];
+  const args = process.argv.slice(4);
+  require('../commands/business').businessCommand(subcommand, ...args)
+    .then(() => process.exit(0))
+    .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
 } else if (command === 'plugin') {
   const subcommand = process.argv[3] || 'build';
   const args = process.argv.slice(4);
   require('../commands/plugin').pluginCommand(subcommand, ...args);
+} else if (command === 'experiments') {
+  const subcommand = process.argv[3];
+  const args = process.argv.slice(4);
+  require('../commands/experiments').experimentsCommand(subcommand, ...args);
 } else {
   console.log(`Unknown command: ${command}`);
   console.log('Run "atris help" to see available commands');
@@ -1292,4 +1364,3 @@ async function atrisDevEntry(userInput = null) {
   console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
   console.log('');
 }
-

package/commands/business.js

@@ -0,0 +1,132 @@
+const fs = require('fs');
+const path = require('path');
+const { loadCredentials } = require('../utils/auth');
+const { apiRequestJson } = require('../utils/api');
+
+function getBusinessConfigPath() {
+  const home = require('os').homedir();
+  const dir = path.join(home, '.atris');
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  return path.join(dir, 'businesses.json');
+}
+
+function loadBusinesses() {
+  const p = getBusinessConfigPath();
+  if (!fs.existsSync(p)) return {};
+  try { return JSON.parse(fs.readFileSync(p, 'utf8')); } catch { return {}; }
+}
+
+function saveBusinesses(data) {
+  fs.writeFileSync(getBusinessConfigPath(), JSON.stringify(data, null, 2));
+}
+
+async function addBusiness(slug) {
+  if (!slug) {
+    console.error('Usage: atris business add <slug>');
+    process.exit(1);
+  }
+
+  const creds = loadCredentials();
+  if (!creds || !creds.token) {
+    console.error('Not logged in. Run: atris login');
+    process.exit(1);
+  }
+
+  // Resolve slug to business
+  const result = await apiRequestJson(`/businesses/by-slug/${slug}`, {
+    method: 'GET',
+    token: creds.token,
+  });
+
+  if (!result.ok) {
+    // Try listing all and matching
+    const listResult = await apiRequestJson('/businesses/', { method: 'GET', token: creds.token });
+    if (listResult.ok && Array.isArray(listResult.data)) {
+      const match = listResult.data.find(b => b.slug === slug || b.name.toLowerCase() === slug.toLowerCase());
+      if (match) {
+        const businesses = loadBusinesses();
+        businesses[slug] = {
+          business_id: match.id,
+          workspace_id: match.workspace_id,
+          name: match.name,
+          slug: match.slug,
+          added_at: new Date().toISOString(),
+        };
+        saveBusinesses(businesses);
+        console.log(`\nAdded "${match.name}" (${match.slug})`);
+        return;
+      }
+    }
+    console.error(`Business "${slug}" not found.`);
+    process.exit(1);
+  }
+
+  const biz = result.data;
+  const businesses = loadBusinesses();
+  businesses[slug] = {
+    business_id: biz.id,
+    workspace_id: biz.workspace_id,
+    name: biz.name,
+    slug: biz.slug,
+    added_at: new Date().toISOString(),
+  };
+  saveBusinesses(businesses);
+  console.log(`\nAdded "${biz.name}" (${biz.slug})`);
+}
+
+async function listBusinesses() {
+  const businesses = loadBusinesses();
+  const slugs = Object.keys(businesses);
+
+  if (slugs.length === 0) {
+    console.log('\nNo businesses connected. Run: atris business add <slug>');
+    return;
+  }
+
+  console.log('\nConnected businesses:\n');
+  for (const slug of slugs) {
+    const b = businesses[slug];
+    console.log(`  ${b.name || slug} (${b.slug || slug})`);
+    console.log(`    ID: ${b.business_id}`);
+    console.log(`    Added: ${b.added_at || 'unknown'}`);
+    console.log('');
+  }
+}
+
+async function removeBusiness(slug) {
+  if (!slug) {
+    console.error('Usage: atris business remove <slug>');
+    process.exit(1);
+  }
+
+  const businesses = loadBusinesses();
+  if (!businesses[slug]) {
+    console.error(`Business "${slug}" not connected.`);
+    process.exit(1);
+  }
+
+  const name = businesses[slug].name || slug;
+  delete businesses[slug];
+  saveBusinesses(businesses);
+  console.log(`\nRemoved "${name}"`);
+}
+
+async function businessCommand(subcommand, ...args) {
+  switch (subcommand) {
+    case 'add':
+      await addBusiness(args[0]);
+      break;
+    case 'list':
+    case 'ls':
+      await listBusinesses();
+      break;
+    case 'remove':
+    case 'rm':
+      await removeBusiness(args[0]);
+      break;
+    default:
+      console.log('Usage: atris business <add|list|remove> [slug]');
+  }
+}
+
+module.exports = { businessCommand, loadBusinesses, saveBusinesses, getBusinessConfigPath };

package/commands/clean.js

@@ -162,7 +162,8 @@ function findStaleTasks(atrisDir) {
 }
 
 /**
- * Find and heal broken MAP.md references
+ * Find and heal broken MAP.md references (single-line AND range refs)
+ * Detects both out-of-bounds AND drift (symbol moved to different line)
  * Returns { healed: number, unhealable: array }
  */
 function healBrokenMapRefs(cwd, atrisDir, dryRun = false) {
@@ -173,68 +174,85 @@ function healBrokenMapRefs(cwd, atrisDir, dryRun = false) {
   const unhealable = [];
   let healed = 0;
 
-  // Match patterns like `file.js:123` with surrounding context
-  // Capture: full match, file path, extension, line number, and context after
-  const refPattern = /(`?)([a-zA-Z0-9_\-./\\]+\.(js|ts|py|go|rs|rb|java|c|cpp|h|hpp|md|json|yaml|yml)):(\d+)(`?)(\s*[\(\[—\-]?\s*([^)\]\n]+))?/g;
+  // Match both `file.js:123` and `file.js:123-456` with surrounding context
+  // [^\S\n] = horizontal whitespace only (no newlines)
+  // Required delimiter [(,[,—,-] prevents bleeding into adjacent refs on same line
+  const refPattern = /(`?)([a-zA-Z0-9_\-./\\]+\.(js|ts|py|go|rs|rb|java|c|cpp|h|hpp|md|json|yaml|yml)):(\d+)(?:-(\d+))?(`?)([^\S\n]*[\(\[—\-][^\S\n]*([^)\]\n]+))?/g;
+
+  // Cache file reads
+  const fileCache = {};
+  function readFileCached(filePath) {
+    if (!fileCache[filePath]) {
+      const fullPath = path.join(cwd, filePath);
+      if (!fs.existsSync(fullPath)) return null;
+      try {
+        const content = fs.readFileSync(fullPath, 'utf8');
+        fileCache[filePath] = { content, lines: content.split('\n') };
+      } catch { return null; }
+    }
+    return fileCache[filePath];
+  }
 
   const replacements = [];
   let match;
 
   while ((match = refPattern.exec(mapContent)) !== null) {
-    const fullMatch = match[0];
     const backtickBefore = match[1] || '';
     const filePath = match[2];
-    const ext = match[3];
-    const lineNum = parseInt(match[4], 10);
-    const backtickAfter = match[5] || '';
-    const contextPart = match[7] || '';
-
-    const fullPath = path.join(cwd, filePath);
-
-    // Check if file exists
-    if (!fs.existsSync(fullPath)) {
-      unhealable.push({ file: filePath, line: lineNum, reason: 'File not found' });
+    const startLine = parseInt(match[4], 10);
+    const endLine = match[5] ? parseInt(match[5], 10) : null;
+    const backtickAfter = match[6] || '';
+    const contextPart = match[8] || '';
+
+    const file = readFileCached(filePath);
+    if (!file) {
+      unhealable.push({ file: filePath, line: startLine, reason: 'File not found' });
       continue;
     }
 
-    // Read file and check line number
-    let fileContent;
-    try {
-      fileContent = fs.readFileSync(fullPath, 'utf8');
-    } catch (err) {
-      unhealable.push({ file: filePath, line: lineNum, reason: `Cannot read: ${err.message}` });
-      continue;
-    }
+    const symbol = extractSymbol(contextPart);
 
-    const lines = fileContent.split('\n');
+    // Check if reference is still accurate
+    const outOfBounds = startLine > file.lines.length || (endLine && endLine > file.lines.length);
+    const drifted = symbol && startLine <= file.lines.length && !symbolAtLine(file.content, symbol, startLine);
 
-    // If line number is valid, skip
-    if (lineNum <= lines.length) {
-      continue;
-    }
-
-    // Line number is broken - try to heal
-    const symbol = extractSymbol(contextPart);
+    if (!outOfBounds && !drifted) continue;
 
     if (!symbol) {
-      unhealable.push({ file: filePath, line: lineNum, reason: 'No symbol to search for' });
+      unhealable.push({ file: filePath, line: startLine, reason: 'No symbol to search for' });
       continue;
     }
 
-    // Search for the symbol in the file
-    const newLine = findSymbolLine(fileContent, symbol);
-
-    if (!newLine) {
-      unhealable.push({ file: filePath, line: lineNum, reason: `Symbol "${symbol}" not found` });
+    // Find where the symbol actually is now
+    const newStart = findSymbolLine(file.content, symbol);
+    if (!newStart) {
+      unhealable.push({ file: filePath, line: startLine, reason: `Symbol "${symbol}" not found` });
       continue;
     }
 
-    // Record the replacement
-    const oldRef = `${backtickBefore}${filePath}:${lineNum}${backtickAfter}`;
-    const newRef = `${backtickBefore}${filePath}:${newLine}${backtickAfter}`;
+    if (endLine) {
+      // Range ref: find new end by scanning for function end
+      const originalSpan = endLine - startLine;
+      const newEnd = findFunctionEnd(file.lines, newStart) || (newStart + originalSpan);
+      const clampedEnd = Math.min(newEnd, file.lines.length);
+
+      const oldRef = `${backtickBefore}${filePath}:${startLine}-${endLine}${backtickAfter}`;
+      const newRef = `${backtickBefore}${filePath}:${newStart}-${clampedEnd}${backtickAfter}`;
 
-    replacements.push({ old: oldRef, new: newRef, symbol });
-    healed++;
+      if (oldRef !== newRef) {
+        replacements.push({ old: oldRef, new: newRef, symbol });
+        healed++;
+      }
+    } else {
+      // Single-line ref
+      const oldRef = `${backtickBefore}${filePath}:${startLine}${backtickAfter}`;
+      const newRef = `${backtickBefore}${filePath}:${newStart}${backtickAfter}`;
+
+      if (oldRef !== newRef) {
+        replacements.push({ old: oldRef, new: newRef, symbol });
+        healed++;
+      }
+    }
   }
 
   // Apply replacements
@@ -245,7 +263,45 @@ function healBrokenMapRefs(cwd, atrisDir, dryRun = false) {
     fs.writeFileSync(mapFile, mapContent);
   }
 
-  return { healed, unhealable };
+  return { healed, unhealable, replacements: dryRun ? replacements : [] };
+}
+
+/**
+ * Check if a symbol is actually defined at or near a given line
+ */
+function symbolAtLine(fileContent, symbol, lineNum) {
+  const lines = fileContent.split('\n');
+  // Check a 5-line window around the referenced line
+  const start = Math.max(0, lineNum - 3);
+  const end = Math.min(lines.length, lineNum + 2);
+  const escaped = escapeRegExp(symbol);
+  const re = new RegExp(`\\b${escaped}\\b`);
+  for (let i = start; i < end; i++) {
+    if (re.test(lines[i])) return true;
+  }
+  return false;
+}
+
+/**
+ * Find the end line of a function starting at startLine (1-indexed)
+ * Tracks brace depth to find the matching closing brace
+ */
+function findFunctionEnd(lines, startLine) {
+  let depth = 0;
+  let foundOpen = false;
+
+  for (let i = startLine - 1; i < lines.length; i++) {
+    const line = lines[i];
+    for (const ch of line) {
+      if (ch === '{') { depth++; foundOpen = true; }
+      if (ch === '}') { depth--; }
+    }
+    if (foundOpen && depth === 0) {
+      return i + 1; // 1-indexed
+    }
+  }
+
+  return null;
 }
 
 /**
@@ -256,6 +312,7 @@ function extractSymbol(context) {
 
   // Clean up the context
   const cleaned = context.trim()
+    .replace(/`/g, '')                // Strip backticks
     .replace(/^[\(\[—\-:]+\s*/, '')  // Remove leading punctuation
     .replace(/[\)\]]+$/, '')          // Remove trailing brackets
     .trim();
@@ -280,45 +337,31 @@ function extractSymbol(context) {
 }
 
 /**
- * Find the line number where a symbol is defined
+ * Find the line number where a symbol is defined (strict patterns only)
+ * Returns null if only loose matches found — prevents healing to wrong locations
  */
 function findSymbolLine(fileContent, symbol) {
   const lines = fileContent.split('\n');
+  const esc = escapeRegExp(symbol);
 
-  // Patterns to match symbol definitions
+  // Strict definition patterns only — no loose fallback
   const patterns = [
-    // function name(
-    new RegExp(`^\\s*(async\\s+)?function\\s+${escapeRegExp(symbol)}\\s*\\(`),
-    // const/let/var name =
-    new RegExp(`^\\s*(const|let|var)\\s+${escapeRegExp(symbol)}\\s*=`),
-    // class name
-    new RegExp(`^\\s*class\\s+${escapeRegExp(symbol)}\\b`),
-    // name: function or name() {
-    new RegExp(`^\\s*${escapeRegExp(symbol)}\\s*[:(]`),
-    // exports.name or module.exports.name
-    new RegExp(`exports\\.${escapeRegExp(symbol)}\\s*=`),
-    // def name( for Python
-    new RegExp(`^\\s*def\\s+${escapeRegExp(symbol)}\\s*\\(`),
-    // Just the symbol on a line (loose match)
-    new RegExp(`\\b${escapeRegExp(symbol)}\\b`)
+    new RegExp(`^\\s*(async\\s+)?function\\s+${esc}\\s*\\(`),  // function name(
+    new RegExp(`^\\s*(const|let|var)\\s+${esc}\\s*=`),          // const/let/var name =
+    new RegExp(`^\\s*class\\s+${esc}\\b`),                      // class name
+    new RegExp(`^\\s*${esc}\\s*[:(]`),                           // name: or name(
+    new RegExp(`exports\\.${esc}\\s*=`),                         // exports.name =
+    new RegExp(`^\\s*def\\s+${esc}\\s*\\(`),                     // def name( (Python)
   ];
 
-  // Try strict patterns first
-  for (let i = 0; i < patterns.length - 1; i++) {
+  for (const pattern of patterns) {
     for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
-      if (patterns[i].test(lines[lineIdx])) {
-        return lineIdx + 1; // 1-indexed
+      if (pattern.test(lines[lineIdx])) {
+        return lineIdx + 1;
       }
     }
   }
 
-  // Fallback: loose match (just contains the symbol)
-  for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
-    if (patterns[patterns.length - 1].test(lines[lineIdx])) {
-      return lineIdx + 1;
-    }
-  }
-
   return null;
 }