atris 3.12.1 → 3.14.0

package/commands/proof.js

@@ -0,0 +1,115 @@
+const fs = require('fs');
+const path = require('path');
+
+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'));
+  } catch {
+    return null;
+  }
+}
+
+function slugify(value) {
+  return String(value || 'business-workflow')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '') || 'business-workflow';
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function writeJson(filePath, value) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function doctor(cwd = process.cwd()) {
+  const binding = readBusinessBinding(cwd);
+  console.log('Receipt check');
+  console.log(`business binding: ${binding ? `${binding.name || binding.slug || binding.business_id} ready` : 'missing'}`);
+  console.log(`receipt folder: ${fs.existsSync(path.join(cwd, '.atris', 'receipts')) ? 'ready' : 'missing'}`);
+  console.log('');
+  console.log('Next: atris receipt init business-workflow');
+}
+
+function init(taskSlug = 'business-workflow', cwd = process.cwd()) {
+  const binding = readBusinessBinding(cwd);
+  if (!binding) {
+    console.error('No business binding found. Run: atris business init <name> --here');
+    process.exitCode = 1;
+    return;
+  }
+
+  const slug = slugify(taskSlug);
+  const root = path.join(cwd, '.atris');
+  const taskPath = path.join(root, 'tasks', `${slug}.json`);
+  const receiptsDir = path.join(root, 'receipts');
+
+  ensureDir(receiptsDir);
+  fs.writeFileSync(path.join(receiptsDir, '.gitkeep'), '');
+  writeJson(taskPath, {
+    schema: 'atris.receipt_task.v1',
+    slug,
+    goal: 'Run one business-computer task and save what happened.',
+    workspace: {
+      business_id: binding.business_id || binding.id || null,
+      workspace_id: binding.workspace_id || null,
+      name: binding.name || null,
+      slug: binding.slug || null,
+    },
+    runtime: {
+      proof_command: 'atris computer proof',
+      replay_command: 'atris experiments replay endstate',
+    },
+    verify: [
+      'atris computer proof',
+      'atris experiments replay endstate',
+    ],
+  });
+
+  console.log(`Receipt task ready: ${slug}`);
+  console.log(`Task: ${path.relative(cwd, taskPath)}`);
+  console.log(`Receipts: ${path.relative(cwd, receiptsDir)}`);
+}
+
+function run(args = []) {
+  const dryRun = args.includes('--dry-run');
+  console.log('Receipt run');
+  console.log('1. atris computer proof');
+  console.log('2. atris experiments replay endstate');
+  if (dryRun) {
+    console.log('Dry run only; no receipts written.');
+    return;
+  }
+  console.log('Run those commands, then save the receipt under .atris/receipts/.');
+}
+
+function proofCommand(subcommand = 'doctor', ...args) {
+  switch (subcommand || 'doctor') {
+    case 'doctor':
+      return doctor();
+    case 'init':
+      return init(args[0] || 'business-workflow');
+    case 'proof':
+      return run(args);
+    case 'help':
+    case '--help':
+    case '-h':
+      console.log('Usage: atris receipt [doctor|init <slug>|run --dry-run]');
+      return;
+    case 'run':
+      return run(args);
+    default:
+      console.error(`Unknown receipt command: ${subcommand}`);
+      console.log('Usage: atris receipt [doctor|init <slug>|run --dry-run]');
+      process.exitCode = 1;
+  }
+}
+
+module.exports = {
+  proofCommand,
+};

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,14 +700,17 @@ 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,
   }, null, 2));
 
-  // Wire skills → .claude/skills/ so they work as slash commands
-  const skillsDir = path.join(outputDir, 'skills');
+  // Wire skills → .claude/skills/ so they work as slash commands.
+  // Source of truth is atris/skills/ (vendor-neutral, syncs to cloud).
+  // .claude/skills/ is a locally-generated adapter Claude Code reads from.
+  const skillsDir = path.join(outputDir, 'atris', 'skills');
   const claudeSkillsDir = path.join(outputDir, '.claude', 'skills');
 
   if (fs.existsSync(skillsDir)) {

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;
@@ -367,6 +367,12 @@ async function pushAtris() {
 
     if (!result.ok) {
       if (result.status === 403) {
+        const detail = result.errorMessage || result.error || (result.data && result.data.detail) || '';
+        if (detail && /plan required|business, max, or enterprise/i.test(detail)) {
+          console.error(`\n  Access denied: ${detail}`);
+          await emit('access_denied', { error_detail: detail });
+          process.exit(1);
+        }
         // Permission denied — retry with only team/ and journal/ files
         const allowed = filesToPush.filter(f => f.path.startsWith('/team/') || f.path.startsWith('/journal/'));
         skipped = filesToPush.filter(f => !f.path.startsWith('/team/') && !f.path.startsWith('/journal/'));

package/commands/task.js

@@ -0,0 +1,217 @@
+// `atris task` — SQLite-backed task plane. TODO.md stays the human-readable
+// board; this gives agents atomic claims and a compact sync row.
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const DEFAULT_OWNER = process.env.ATRIS_AGENT_ID
+  || process.env.USER
+  || os.userInfo().username
+  || 'unknown';
+
+let taskDbModule = null;
+
+function getTaskDb() {
+  if (taskDbModule) return taskDbModule;
+  try {
+    taskDbModule = require('../lib/task-db');
+    return taskDbModule;
+  } catch (e) {
+    const message = String(e && (e.message || e));
+    const missingSqlite = e && (
+      e.code === 'ERR_UNKNOWN_BUILTIN_MODULE'
+      || /node:sqlite|No such built-in module/i.test(message)
+    );
+    if (missingSqlite) {
+      console.error('atris task requires Node.js 22+ because it uses built-in node:sqlite.');
+      console.error('Use the markdown TODO.md flow on older Node versions.');
+      process.exit(1);
+    }
+    throw e;
+  }
+}
+
+function help() {
+  console.log(`
+atris task — local agent task plane (SQLite, gitignored)
+
+  atris task add "<title>" [--tag <tag>]   Create a task
+  atris task list [--all] [--status <s>]   List tasks (default: this workspace)
+  atris task claim <id> [--as <owner>]     Atomic claim
+  atris task done <id> [--failed]          Mark complete (or failed)
+  atris task import <file>                 One-shot import from TODO.md
+  atris task where                          Print db path + workspace scope
+  atris task help                           This help
+
+Env:
+  ATRIS_TASKS_DB    Override db path (default ~/.atris/tasks.db)
+  ATRIS_AGENT_ID    Owner id for claim/done (default: $USER)
+`.trim());
+}
+
+function flag(args, name) {
+  const i = args.indexOf(name);
+  if (i === -1) return null;
+  return args[i + 1] || true;
+}
+
+function hasFlag(args, name) {
+  return args.indexOf(name) !== -1;
+}
+
+function positional(args) {
+  return args.filter((a, i) => {
+    if (a.startsWith('--')) return false;
+    if (i > 0 && args[i - 1].startsWith('--')) return false;
+    return true;
+  });
+}
+
+function cmdAdd(args) {
+  const pos = positional(args);
+  const title = pos.join(' ').trim();
+  if (!title) {
+    console.error('atris task add: title required');
+    process.exit(2);
+  }
+  const tag = flag(args, '--tag');
+  const taskDb = getTaskDb();
+  const db = taskDb.open();
+  const ws = taskDb.workspaceRoot();
+  const result = taskDb.addTask(db, {
+    title,
+    tag: typeof tag === 'string' ? tag : null,
+    workspaceRoot: ws,
+  });
+  console.log(`${result.id}\t${title}`);
+}
+
+function cmdList(args) {
+  const all = hasFlag(args, '--all');
+  const status = flag(args, '--status');
+  const taskDb = getTaskDb();
+  const db = taskDb.open();
+  const rows = taskDb.listTasks(db, {
+    workspaceRoot: all ? null : taskDb.workspaceRoot(),
+    status: typeof status === 'string' ? status : null,
+    limit: 200,
+  });
+  if (rows.length === 0) {
+    console.log('(no tasks)');
+    return;
+  }
+  for (const r of rows) {
+    const claim = r.claimed_by ? ` [${r.claimed_by}]` : '';
+    const tag = r.tag ? ` #${r.tag}` : '';
+    console.log(`${r.status.padEnd(8)} ${r.id}${claim}${tag}\t${r.title}`);
+  }
+}
+
+function cmdClaim(args) {
+  const pos = positional(args);
+  const id = pos[0];
+  if (!id) {
+    console.error('atris task claim: id required');
+    process.exit(2);
+  }
+  const owner = flag(args, '--as') || DEFAULT_OWNER;
+  const taskDb = getTaskDb();
+  const db = taskDb.open();
+  const result = taskDb.claimTask(db, { id, claimedBy: String(owner) });
+  if (result.claimed) {
+    console.log(`claimed ${id} as ${owner}`);
+  } else {
+    console.error(`claim failed: ${result.reason}${result.claimed_by ? ` (held by ${result.claimed_by})` : ''}`);
+    process.exit(1);
+  }
+}
+
+function cmdDone(args) {
+  const pos = positional(args);
+  const id = pos[0];
+  if (!id) {
+    console.error('atris task done: id required');
+    process.exit(2);
+  }
+  const failed = hasFlag(args, '--failed');
+  const taskDb = getTaskDb();
+  const db = taskDb.open();
+  const result = taskDb.doneTask(db, { id, status: failed ? 'failed' : 'done' });
+  if (result.updated) {
+    console.log(`${failed ? 'failed' : 'done'} ${id}`);
+  } else {
+    console.error(`done failed: ${id} not in open|claimed`);
+    process.exit(1);
+  }
+}
+
+function cmdImport(args) {
+  const pos = positional(args);
+  const target = pos[0] || 'atris/TODO.md';
+  const filePath = path.resolve(target);
+  if (!fs.existsSync(filePath)) {
+    console.error(`atris task import: file not found: ${filePath}`);
+    process.exit(2);
+  }
+  const { parseTodoFile } = require('../lib/todo-fallback');
+  const parsed = parseTodoFile(filePath);
+  const taskDb = getTaskDb();
+  const db = taskDb.open();
+  const ws = taskDb.workspaceRoot();
+  const all = [
+    ...parsed.backlog.map(t => ({ ...t, importStatus: 'open' })),
+    ...parsed.inProgress.map(t => ({ ...t, importStatus: 'claimed' })),
+  ];
+  let inserted = 0;
+  let skipped = 0;
+  for (const t of all) {
+    if (!t.title) continue;
+    const sk = taskDb.sourceKey(filePath, t.title);
+    const result = taskDb.addTask(db, {
+      title: t.title,
+      tag: t.tag || null,
+      workspaceRoot: ws,
+      sourceKey: sk,
+      status: t.importStatus,
+      claimedBy: t.claimed || null,
+      metadata: { todo_id: t.id, claimed: t.claimed, stage: t.stage, verify: t.verify },
+    });
+    if (result.inserted) inserted++; else skipped++;
+  }
+  console.log(`imported ${inserted} new, skipped ${skipped} (already imported), source=${filePath}`);
+}
+
+function cmdWhere() {
+  const taskDb = getTaskDb();
+  console.log(`db:        ${taskDb.getDbPath()}`);
+  console.log(`workspace: ${taskDb.workspaceRoot()}`);
+  console.log(`owner:     ${DEFAULT_OWNER}`);
+}
+
+async function run(args) {
+  const sub = (args && args[0]) || 'help';
+  const rest = (args || []).slice(1);
+  switch (sub) {
+    case 'add':    return cmdAdd(rest);
+    case 'list':   return cmdList(rest);
+    case 'ls':     return cmdList(rest);
+    case 'claim':  return cmdClaim(rest);
+    case 'done':   return cmdDone(rest);
+    case 'fail':   return cmdDone([...rest, '--failed']);
+    case 'import': return cmdImport(rest);
+    case 'where':  return cmdWhere();
+    case 'help':
+    case '--help':
+    case '-h':
+      return help();
+    default:
+      console.error(`atris task: unknown subcommand "${sub}"`);
+      help();
+      process.exit(2);
+  }
+}
+
+module.exports = { run };