atris 3.12.1 → 3.14.0

package/commands/business.js

@@ -13,16 +13,312 @@ function getBusinessConfigPath() {
   return path.join(dir, 'businesses.json');
 }
 
+function slugify(name) {
+  return String(name || '')
+    .toLowerCase()
+    .trim()
+    .replace(/[^a-z0-9\s-]/g, '')
+    .replace(/\s+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+function isHelpToken(arg) {
+  return arg === '--help' || arg === '-h' || arg === 'help' || arg === '-?';
+}
+
 function loadBusinesses() {
   const p = getBusinessConfigPath();
   if (!fs.existsSync(p)) return {};
   try { return JSON.parse(fs.readFileSync(p, 'utf8')); } catch { return {}; }
 }
 
+function businessAliases(business) {
+  const aliases = business?.aliases || business?.config?.aliases || [];
+  return Array.isArray(aliases) ? aliases : [];
+}
+
+function businessMatchesSlug(business, slug, { includeName = false } = {}) {
+  if (!business || !slug) return false;
+  const wanted = String(slug).toLowerCase();
+  const canonical = String(business.slug || '').toLowerCase();
+  const aliases = businessAliases(business).map((alias) => String(alias).toLowerCase());
+  if (canonical === wanted || aliases.includes(wanted)) return true;
+  return includeName && String(business.name || '').toLowerCase() === wanted;
+}
+
 function saveBusinesses(data) {
   fs.writeFileSync(getBusinessConfigPath(), JSON.stringify(data, null, 2));
 }
 
+function buildBusinessCacheEntry(business, localSlug, existing = {}) {
+  const aliases = businessAliases(business);
+  const entry = {
+    business_id: business.id || business.business_id,
+    workspace_id: business.workspace_id,
+    name: business.name || localSlug,
+    slug: localSlug || business.slug,
+    added_at: existing.added_at || new Date().toISOString(),
+  };
+  if (business.slug && business.slug !== entry.slug) entry.canonical_slug = business.slug;
+  else if (business.slug) entry.canonical_slug = business.slug;
+  if (aliases.length > 0) entry.aliases = aliases;
+  return entry;
+}
+
+function readBusinessFolderBindings(rootDir = path.join(os.homedir(), 'arena', 'atris-business')) {
+  const skip = new Set([
+    '.git', '.DS_Store', 'archive', 'archives', '_archive', 'bench', 'deals',
+    'node_modules', 'shelf', '_shelf', 'templates',
+  ]);
+  if (!fs.existsSync(rootDir)) return [];
+
+  return fs.readdirSync(rootDir, { withFileTypes: true })
+    .filter((entry) => !entry.name.startsWith('.') && !skip.has(entry.name))
+    .map((entry) => {
+      const fullPath = path.join(rootDir, entry.name);
+      let isDirectory = entry.isDirectory();
+      const isSymlink = entry.isSymbolicLink();
+      let symlinkTarget = null;
+      if (isSymlink) {
+        try {
+          symlinkTarget = fs.readlinkSync(fullPath);
+          isDirectory = fs.statSync(fullPath).isDirectory();
+        } catch {
+          isDirectory = false;
+        }
+      }
+      if (!isDirectory) return null;
+
+      const businessJsonPath = path.join(fullPath, '.atris', 'business.json');
+      const atrisDir = path.join(fullPath, 'atris');
+      const binding = {
+        name: entry.name,
+        path: fullPath,
+        isSymlink,
+        symlinkTarget,
+        hasAtris: fs.existsSync(atrisDir) && fs.statSync(atrisDir).isDirectory(),
+        hasBusinessJson: fs.existsSync(businessJsonPath),
+        businessJsonPath,
+        meta: null,
+        error: null,
+      };
+
+      if (binding.hasBusinessJson) {
+        try {
+          binding.meta = JSON.parse(fs.readFileSync(businessJsonPath, 'utf8'));
+        } catch (err) {
+          binding.error = err.message || 'invalid JSON';
+        }
+      }
+      return binding;
+    })
+    .filter(Boolean);
+}
+
+function analyzeBusinessDoctor({ cache = {}, cloudBusinesses = [], folderBindings = [] } = {}) {
+  const issues = [];
+  const cacheUpdates = {};
+  const activeById = new Map();
+  const activeBySlug = new Map();
+  const realFolderIds = new Map();
+
+  for (const business of cloudBusinesses || []) {
+    const id = business.id || business.business_id;
+    if (!id) continue;
+    activeById.set(id, business);
+    if (business.slug) {
+      const lower = String(business.slug).toLowerCase();
+      if (activeBySlug.has(lower)) {
+        issues.push({
+          level: 'fail',
+          code: 'duplicate-active-slug',
+          subject: business.slug,
+          message: `multiple active cloud businesses use slug ${business.slug}`,
+        });
+      }
+      activeBySlug.set(lower, business);
+    }
+  }
+
+  const findActiveMatch = (key, entry = {}) => {
+    if (entry.business_id && activeById.has(entry.business_id)) return activeById.get(entry.business_id);
+    const candidates = [key, entry.slug, entry.canonical_slug, entry.name].filter(Boolean);
+    return cloudBusinesses.find((business) =>
+      candidates.some((candidate) => businessMatchesSlug(business, candidate, { includeName: true }))
+    ) || null;
+  };
+
+  for (const [key, entry] of Object.entries(cache || {})) {
+    const active = findActiveMatch(key, entry);
+    if (!active) {
+      issues.push({
+        level: 'fail',
+        code: 'stale-cache',
+        subject: key,
+        message: `${key} points at a deleted/inaccessible business (${entry.business_id || 'missing id'})`,
+      });
+      continue;
+    }
+
+    if (entry.business_id && entry.business_id !== active.id) {
+      issues.push({
+        level: 'fail',
+        code: 'stale-cache-repoint',
+        subject: key,
+        message: `${key} points at ${entry.business_id}; active cloud row is ${active.id}`,
+        fixable: true,
+      });
+      cacheUpdates[key] = buildBusinessCacheEntry(active, key, entry);
+    }
+
+    if (!businessMatchesSlug({ ...active, aliases: businessAliases(active) }, key, { includeName: true }) && key !== active.slug) {
+      issues.push({
+        level: 'warn',
+        code: 'cache-key-not-alias',
+        subject: key,
+        message: `${key} is cached but is not the canonical slug, alias, or name for ${active.slug}`,
+      });
+    }
+  }
+
+  for (const business of cloudBusinesses || []) {
+    const canonicalKey = business.slug;
+    if (canonicalKey && (!cache[canonicalKey] || cache[canonicalKey].business_id !== business.id)) {
+      issues.push({
+        level: 'warn',
+        code: 'missing-canonical-cache',
+        subject: canonicalKey,
+        message: `${canonicalKey} is active in cloud but missing/stale in local cache`,
+        fixable: true,
+      });
+      cacheUpdates[canonicalKey] = buildBusinessCacheEntry(business, canonicalKey, cache[canonicalKey]);
+    }
+
+    for (const alias of businessAliases(business)) {
+      if (!cache[alias] || cache[alias].business_id !== business.id) {
+        issues.push({
+          level: 'warn',
+          code: 'missing-alias-cache',
+          subject: alias,
+          message: `${alias} is an active alias for ${business.slug} but missing/stale in local cache`,
+          fixable: true,
+        });
+        cacheUpdates[alias] = buildBusinessCacheEntry(business, alias, cache[alias]);
+      }
+    }
+  }
+
+  for (const binding of folderBindings || []) {
+    if (binding.error) {
+      issues.push({
+        level: 'fail',
+        code: 'invalid-business-json',
+        subject: binding.name,
+        message: `${binding.name}/.atris/business.json is invalid: ${binding.error}`,
+      });
+      continue;
+    }
+
+    if (!binding.hasBusinessJson) {
+      if (binding.hasAtris && !binding.isSymlink) {
+        issues.push({
+          level: 'warn',
+          code: 'folder-unbound',
+          subject: binding.name,
+          message: `${binding.name} has atris/ but no .atris/business.json`,
+        });
+      }
+      continue;
+    }
+
+    const meta = binding.meta || {};
+    const active = findActiveMatch(binding.name, {
+      business_id: meta.business_id,
+      slug: meta.slug,
+      canonical_slug: meta.canonical_slug,
+      name: meta.name,
+    });
+
+    if (!active) {
+      issues.push({
+        level: 'fail',
+        code: 'stale-folder-binding',
+        subject: binding.name,
+        message: `${binding.name} is bound to deleted/inaccessible business ${meta.business_id || meta.slug || 'unknown'}`,
+      });
+      continue;
+    }
+
+    if (meta.business_id && meta.business_id !== active.id) {
+      issues.push({
+        level: 'fail',
+        code: 'folder-id-mismatch',
+        subject: binding.name,
+        message: `${binding.name} points at ${meta.business_id}; active cloud row is ${active.id}`,
+      });
+    }
+
+    if (meta.slug && !businessMatchesSlug(active, meta.slug, { includeName: true })) {
+      issues.push({
+        level: 'fail',
+        code: 'folder-slug-mismatch',
+        subject: binding.name,
+        message: `${binding.name} uses slug ${meta.slug}, which is not ${active.slug} or an alias`,
+      });
+    }
+
+    if (!businessMatchesSlug(active, binding.name, { includeName: false }) && !binding.isSymlink) {
+      issues.push({
+        level: 'warn',
+        code: 'folder-name-not-slug-or-alias',
+        subject: binding.name,
+        message: `${binding.name} is not a canonical slug or alias for ${active.slug}`,
+      });
+    }
+
+    if (!binding.isSymlink) {
+      const existing = realFolderIds.get(active.id) || [];
+      existing.push(binding.name);
+      realFolderIds.set(active.id, existing);
+    }
+
+    const cacheKey = meta.slug || binding.name;
+    if (!cache[cacheKey] || cache[cacheKey].business_id !== active.id) {
+      issues.push({
+        level: 'warn',
+        code: 'folder-cache-missing',
+        subject: cacheKey,
+        message: `${binding.name} is bound locally but ${cacheKey} is missing/stale in local cache`,
+        fixable: true,
+      });
+      cacheUpdates[cacheKey] = buildBusinessCacheEntry(active, cacheKey, cache[cacheKey]);
+    }
+  }
+
+  for (const [businessId, names] of realFolderIds.entries()) {
+    if (names.length > 1) {
+      issues.push({
+        level: 'fail',
+        code: 'duplicate-real-folders',
+        subject: businessId,
+        message: `business ${businessId} has multiple real folders: ${names.join(', ')}`,
+      });
+    }
+  }
+
+  return {
+    issues,
+    cacheUpdates,
+    stats: {
+      cache_entries: Object.keys(cache || {}).length,
+      cloud_active: cloudBusinesses.length,
+      folders: folderBindings.length,
+      fixable_cache_entries: Object.keys(cacheUpdates).length,
+    },
+  };
+}
+
 function parseCreateBusinessFlags(flags, cwd = process.cwd()) {
   const options = {
     description: '',
@@ -774,7 +1070,45 @@ function detectBusinessSlug(explicitSlug) {
   }
 }
 
+async function findExistingBusinessBySlug(slug, token) {
+  if (!slug) return null;
+
+  // Local cache first — no network round-trip needed.
+  const local = loadBusinesses();
+  if (local[slug]) {
+    return { id: local[slug].business_id, name: local[slug].name, slug, source: 'local' };
+  }
+  for (const v of Object.values(local)) {
+    if (businessMatchesSlug(v, slug)) {
+      return { id: v.business_id, name: v.name, slug, source: 'local' };
+    }
+  }
+
+  if (!token) return null;
+
+  // Cloud lookup — covers businesses the user is a member of but hasn't added.
+  const direct = await apiRequestJson(`/business/by-slug/${encodeURIComponent(slug)}`, {
+    method: 'GET',
+    token,
+  });
+  if (direct.ok && direct.data && direct.data.id) {
+    return { id: direct.data.id, name: direct.data.name, slug: direct.data.slug || slug, source: 'cloud' };
+  }
+
+  const list = await apiRequestJson('/business/', { method: 'GET', token });
+  if (list.ok && Array.isArray(list.data)) {
+    const match = list.data.find(b => businessMatchesSlug(b, slug));
+    if (match) return { id: match.id, name: match.name, slug: match.slug, source: 'cloud' };
+  }
+
+  return null;
+}
+
 async function addBusiness(slug) {
+  if (!slug || isHelpToken(slug)) {
+    console.error('Usage: atris business add <slug>');
+    process.exit(1);
+  }
   if (!slug) {
     console.error('Usage: atris business add <slug>');
     process.exit(1);
@@ -796,7 +1130,7 @@ async function addBusiness(slug) {
     // Try listing all and matching
     const listResult = await apiRequestJson('/business/', { 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());
+      const match = listResult.data.find(b => businessMatchesSlug(b, slug, { includeName: true }));
       if (match) {
         const businesses = loadBusinesses();
         businesses[slug] = {
@@ -1008,7 +1342,7 @@ function listBusinessesLocal(opts = {}) {
 }
 
 async function removeBusiness(slug) {
-  if (!slug) {
+  if (!slug || isHelpToken(slug)) {
     console.error('Usage: atris business remove <slug>');
     process.exit(1);
   }
@@ -1047,7 +1381,7 @@ async function resolveSlug(slug, creds) {
   // Fallback: list all and match
   const listResult = await apiRequestJson('/business/', { 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());
+    const match = listResult.data.find(b => businessMatchesSlug(b, slug, { includeName: true }));
     if (match) {
       return { business_id: match.id, workspace_id: match.workspace_id, name: match.name, slug: match.slug };
     }
@@ -1261,9 +1595,109 @@ async function businessAudit() {
   console.log('');
 }
 
+function parseBusinessDoctorOptions(args = []) {
+  const options = {
+    fix: args.includes('--fix'),
+    json: args.includes('--json'),
+    root: path.join(os.homedir(), 'arena', 'atris-business'),
+  };
+  const rootIdx = args.indexOf('--root');
+  if (rootIdx !== -1 && args[rootIdx + 1]) {
+    options.root = path.resolve(args[rootIdx + 1]);
+  }
+  return options;
+}
+
+function printBusinessDoctorHelp() {
+  console.log('Usage: atris business doctor [--fix] [--root <dir>] [--json]');
+  console.log('');
+  console.log('Checks cloud-active businesses against:');
+  console.log('  - ~/.atris/businesses.json');
+  console.log('  - ~/arena/atris-business/*/.atris/business.json');
+  console.log('  - canonical slug + alias bindings');
+  console.log('');
+  console.log('--fix rewrites only safe local cache entries. It does not rename folders or touch cloud data.');
+}
+
+async function businessDoctor(...args) {
+  if (args.some(isHelpToken)) {
+    printBusinessDoctorHelp();
+    return;
+  }
+
+  const options = parseBusinessDoctorOptions(args);
+  const creds = loadCredentials();
+  if (!creds || !creds.token) {
+    console.error('Not logged in. Run: atris login');
+    process.exit(1);
+  }
+
+  const listResult = await apiRequestJson('/business/', { method: 'GET', token: creds.token });
+  if (!listResult.ok || !Array.isArray(listResult.data)) {
+    console.error(`Failed to fetch businesses: ${listResult.errorMessage || listResult.error || listResult.status || 'unknown error'}`);
+    process.exit(1);
+  }
+
+  let cache = loadBusinesses();
+  const folderBindings = readBusinessFolderBindings(options.root);
+  let analysis = analyzeBusinessDoctor({
+    cache,
+    cloudBusinesses: listResult.data,
+    folderBindings,
+  });
+
+  const cacheUpdateKeys = Object.keys(analysis.cacheUpdates);
+  let fixed = [];
+  if (options.fix && cacheUpdateKeys.length > 0) {
+    cache = { ...cache, ...analysis.cacheUpdates };
+    saveBusinesses(cache);
+    fixed = cacheUpdateKeys;
+    analysis = analyzeBusinessDoctor({
+      cache,
+      cloudBusinesses: listResult.data,
+      folderBindings,
+    });
+  }
+
+  if (options.json) {
+    console.log(JSON.stringify({
+      root: options.root,
+      stats: analysis.stats,
+      fixed,
+      issues: analysis.issues,
+    }, null, 2));
+  } else {
+    console.log('');
+    console.log('Business Doctor');
+    console.log('---------------');
+    console.log(`cloud active: ${analysis.stats.cloud_active}`);
+    console.log(`cache entries: ${analysis.stats.cache_entries}`);
+    console.log(`folders scanned: ${analysis.stats.folders}`);
+    if (fixed.length > 0) console.log(`fixed cache entries: ${fixed.join(', ')}`);
+    console.log('');
+
+    if (analysis.issues.length === 0) {
+      console.log('OK no business binding drift found.');
+    } else {
+      for (const issue of analysis.issues) {
+        const label = issue.level === 'fail' ? 'FAIL' : 'WARN';
+        const fixHint = issue.fixable ? ' (run with --fix)' : '';
+        console.log(`${label} ${issue.code}: ${issue.message}${fixHint}`);
+      }
+    }
+    console.log('');
+  }
+
+  const failures = analysis.issues.filter((issue) => issue.level === 'fail');
+  if (failures.length > 0) process.exitCode = 1;
+}
+
 async function createBusinessInternal(name, flags = [], mode = 'auto') {
-  if (!name) {
+  if (!name || isHelpToken(name) || String(name).startsWith('-')) {
     console.error('Usage: atris business create <name> [--description "..."] [--workspace] [--here|--root <dir>]');
+    if (name && String(name).startsWith('-') && !isHelpToken(name)) {
+      console.error(`\n  Refusing to create a business named "${name}" — looks like a flag, not a name.`);
+    }
     process.exit(1);
   }
 
@@ -1275,6 +1709,29 @@ async function createBusinessInternal(name, flags = [], mode = 'auto') {
 
   const options = parseCreateBusinessFlags(flags);
   const description = options.description;
+  const force = flags.includes('--force') || flags.includes('--allow-duplicate');
+
+  // Pre-flight: refuse to create a duplicate by slug. The backend will silently
+  // suffix `-1`, `-2`, etc., which produces ghost businesses when users actually
+  // wanted to attach to an existing one. Guide them to `atris pull` instead.
+  if (!force) {
+    const desiredSlug = slugify(name);
+    if (desiredSlug) {
+      const existing = await findExistingBusinessBySlug(desiredSlug, creds.token);
+      if (existing) {
+        console.error(`\nA business with slug "${desiredSlug}" already exists.`);
+        console.error(`  Name: ${existing.name || desiredSlug}`);
+        if (existing.id) console.error(`  ID:   ${existing.id}`);
+        console.error('');
+        console.error('To set up a local workspace for it, run:');
+        console.error(`  atris pull ${desiredSlug}                       # into ./${desiredSlug}`);
+        console.error(`  atris pull ${desiredSlug} --into <path>         # into a custom path`);
+        console.error('');
+        console.error(`To create a NEW business anyway (will be slugged "${desiredSlug}-1"), pass --force.`);
+        process.exit(1);
+      }
+    }
+  }
 
   console.log(`Creating business: ${name}...`);
 
@@ -1700,7 +2157,7 @@ async function deployBusiness(slug) {
     // Try to find by slug in cloud
     const listResult = await apiRequestJson('/business/', { method: 'GET', token: creds.token });
     if (listResult.ok && Array.isArray(listResult.data)) {
-      const match = listResult.data.find(b => b.slug === slug);
+      const match = listResult.data.find(b => businessMatchesSlug(b, slug));
       if (match) {
         bizConfig = { business_id: match.id, workspace_id: match.workspace_id, name: match.name, slug: match.slug };
         businesses[slug] = { ...bizConfig, added_at: new Date().toISOString() };
@@ -1832,12 +2289,53 @@ async function quickstart() {
      (get 1 email/day instead of every notification)
 
   Templates: saas, agency, ecommerce, content, restaurant
+
+  Rule of thumb:
+     atris business init "<name>"    = cloud + local business computer workspace
+     atris business create "<name>"  = cloud-only unless you pass --workspace
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 `);
 }
 
 
+function printBusinessHelp() {
+  console.log('Usage: atris business <command> [args]');
+  console.log('');
+  console.log('  quickstart           ← Start here! 3-command guide');
+  console.log('');
+  console.log('  init <name>          RECOMMENDED: create a business environment (cloud + local)');
+  console.log('  workspace <name>     Alias for init');
+  console.log('  create <name>        Cloud-only business record; add --workspace to also scaffold local');
+  console.log('  add <slug>           Register an existing cloud business');
+  console.log('  list                 Show registered businesses');
+  console.log('  team [slug]          Show members, roles, and admin access');
+  console.log('  status <slug>        Quick status check');
+  console.log('  health [slug]        Full health dashboard');
+  console.log('  audit                Audit all businesses');
+  console.log('  doctor [--fix]       Find stale business cache, alias, and folder bindings');
+  console.log('  connect <service>    Connect a skill/integration');
+  console.log('  notify <mode>        Set notification mode (digest/silent/push)');
+  console.log('  deploy <slug>        Push local business to cloud');
+  console.log('  onboard              Seed brief, person, first loop, safe next action, and one-pager from sparse input');
+  console.log('  record <report>      Append recap state into events, episodes, and scorecards');
+  console.log('  remove <slug>        Unregister locally');
+  console.log('');
+  console.log('  Already-attached business? Run `atris pull <slug>` to scaffold a local workspace.');
+}
+
 async function businessCommand(subcommand, ...args) {
+  // Help intercept — without this, `atris business init --help` would treat
+  // `--help` as a business name and create one. Same for any subcommand that
+  // takes a positional name/slug.
+  if (!subcommand || isHelpToken(subcommand)) {
+    printBusinessHelp();
+    return;
+  }
+  if (args.length > 0 && isHelpToken(args[0]) && subcommand !== 'doctor') {
+    printBusinessHelp();
+    return;
+  }
+
   switch (subcommand) {
     case 'add':
       await addBusiness(args[0]);
@@ -1883,6 +2381,9 @@ async function businessCommand(subcommand, ...args) {
     case 'audit':
       await businessAudit();
       break;
+    case 'doctor':
+      await businessDoctor(...args);
+      break;
     case 'connect':
       await connectService(args[0], ...args.slice(1));
       break;
@@ -1907,25 +2408,10 @@ async function businessCommand(subcommand, ...args) {
       await quickstart();
       break;
     default:
-      console.log('Usage: atris business <command> [args]');
-      console.log('');
-      console.log('  quickstart           ← Start here! 3-command guide');
-      console.log('');
-      console.log('  init <name>          Create a business environment (cloud + local)');
-      console.log('  workspace <name>     Alias for init');
-      console.log('  create <name>        Create the cloud business; add --workspace for a local business environment');
-      console.log('  add <slug>           Register an existing cloud business');
-      console.log('  list                 Show registered businesses');
-      console.log('  team [slug]          Show members, roles, and admin access');
-      console.log('  status <slug>        Quick status check');
-      console.log('  health [slug]        Full health dashboard');
-      console.log('  audit                Audit all businesses');
-      console.log('  connect <service>    Connect a skill/integration');
-      console.log('  notify <mode>        Set notification mode (digest/silent/push)');
-      console.log('  deploy <slug>        Push local business to cloud');
-      console.log('  onboard              Seed brief, person, first loop, safe next action, and one-pager from sparse input');
-      console.log('  record <report>      Append recap state into events, episodes, and scorecards');
-      console.log('  remove <slug>        Unregister locally');
+      console.error(`Unknown subcommand: ${subcommand}`);
+      console.error('');
+      printBusinessHelp();
+      process.exitCode = 1;
   }
 }
 
@@ -1933,10 +2419,14 @@ module.exports = {
   businessCommand,
   businessHealth,
   businessAudit,
+  businessDoctor,
   businessTeam,
   loadBusinesses,
   saveBusinesses,
   getBusinessConfigPath,
+  businessMatchesSlug,
+  analyzeBusinessDoctor,
+  readBusinessFolderBindings,
   createCanonicalBusinessWorkspace,
   initBusinessWorkspace,
   onboardBusiness,