atris 3.13.0 → 3.14.0

package/commands/computer.js

@@ -5,6 +5,7 @@
  *   atris computer --cloud          — Open CLOUD workspace mode
  *   atris computer wake             — Start the computer
  *   atris computer sleep            — Stop (files persist)
+ *   atris computer card             — Show the local computer card
  *   atris computer run <command>    — Run bash on EC2 (no LLM)
  *   atris computer grep <pattern>   — Search files on EC2
  *   atris computer ls [path]        — List files
@@ -705,8 +706,8 @@ async function runLocalBridgeOp(token, sessionId, op, timeoutSeconds = 30) {
   return data;
 }
 
-function readBusinessBinding() {
-  const bindingPath = path.join(process.cwd(), '.atris', 'business.json');
+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'));
@@ -715,6 +716,160 @@ function readBusinessBinding() {
   }
 }
 
+function readPackageMeta(cwd = process.cwd()) {
+  const packagePath = path.join(cwd, 'package.json');
+  if (!fs.existsSync(packagePath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function relIfExists(cwd, target) {
+  return fs.existsSync(path.join(cwd, target)) ? target : null;
+}
+
+function detectValidationCommand(cwd = process.cwd(), pkg = null) {
+  const meta = pkg || readPackageMeta(cwd);
+  const testScript = meta?.scripts?.test;
+  if (testScript && !/no test specified/i.test(testScript)) return 'npm test';
+  if (fs.existsSync(path.join(cwd, 'pytest.ini')) || fs.existsSync(path.join(cwd, 'pyproject.toml'))) return 'pytest';
+  if (fs.existsSync(path.join(cwd, 'Cargo.toml'))) return 'cargo test';
+  if (fs.existsSync(path.join(cwd, 'go.mod'))) return 'go test ./...';
+  return 'none detected';
+}
+
+function detectComputerType(cwd = process.cwd(), pkg = null, binding = null) {
+  if (binding?.computer_type) return binding.computer_type;
+  if (binding?.workspace_type) return binding.workspace_type;
+  const meta = pkg || readPackageMeta(cwd);
+  if (meta?.bin || fs.existsSync(path.join(cwd, 'bin')) || fs.existsSync(path.join(cwd, 'commands'))) return 'codeops';
+  if (fs.existsSync(path.join(cwd, 'docs')) || fs.existsSync(path.join(cwd, 'atris', 'wiki'))) return 'research';
+  return 'workspace';
+}
+
+function buildComputerCard(cwd = process.cwd()) {
+  const binding = readBusinessBinding(cwd);
+  const pkg = readPackageMeta(cwd);
+  const folderName = path.basename(cwd);
+  const ownerName = binding?.name || pkg?.name || folderName;
+  const ownerType = binding ? 'business' : 'project';
+  const computerName = binding?.computer_name || binding?.workspace_name || `${ownerName} computer`;
+  const computerType = detectComputerType(cwd, pkg, binding);
+  const memory = [
+    relIfExists(cwd, 'atris/MAP.md'),
+    relIfExists(cwd, 'atris/TODO.md'),
+    relIfExists(cwd, 'atris/wiki'),
+    relIfExists(cwd, 'atris/logs'),
+  ].filter(Boolean);
+  const artifacts = [
+    fs.existsSync(path.join(cwd, 'atris')) ? 'atris/reports/' : null,
+    relIfExists(cwd, '.atris/receipts'),
+  ].filter(Boolean);
+
+  return {
+    ownerName,
+    ownerType,
+    computerName,
+    computerType,
+    workspace: cwd,
+    loop: 'plan -> do -> review',
+    memory,
+    validation: detectValidationCommand(cwd, pkg),
+    proof: binding ? 'atris computer proof' : 'atris proof run',
+    visual: 'atris visualize "<prompt>"',
+    artifacts,
+    generatedAt: new Date().toISOString(),
+  };
+}
+
+function renderList(items) {
+  return items.length ? items.join(', ') : 'none detected';
+}
+
+function renderComputerCard(card) {
+  return [
+    'Atris Computer Card',
+    '',
+    `  Owner:      ${card.ownerName} (${card.ownerType})`,
+    `  Computer:   ${card.computerName}`,
+    `  Type:       ${card.computerType}`,
+    `  Workspace:  ${card.workspace}`,
+    `  Loop:       ${card.loop}`,
+    `  Memory:     ${renderList(card.memory)}`,
+    `  Validate:   ${card.validation}`,
+    `  Proof:      ${card.proof}`,
+    `  Visual:     ${card.visual}`,
+    `  Artifacts:  ${renderList(card.artifacts)}`,
+  ].join('\n');
+}
+
+function renderComputerCardMarkdown(card) {
+  return [
+    '# Atris Computer Card',
+    '',
+    `Generated: ${card.generatedAt}`,
+    '',
+    `- Owner: ${card.ownerName} (${card.ownerType})`,
+    `- Computer: ${card.computerName}`,
+    `- Type: ${card.computerType}`,
+    `- Workspace: ${card.workspace}`,
+    `- Loop: ${card.loop}`,
+    `- Memory: ${renderList(card.memory)}`,
+    `- Validate: ${card.validation}`,
+    `- Proof: ${card.proof}`,
+    `- Visual: ${card.visual}`,
+    `- Artifacts: ${renderList(card.artifacts)}`,
+    '',
+  ].join('\n');
+}
+
+function parseComputerCardArgs(args = []) {
+  const options = { write: false, out: null, help: false };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--help' || arg === '-h') options.help = true;
+    else if (arg === '--write') options.write = true;
+    else if (arg === '--out' && args[i + 1]) options.out = args[++i];
+    else if (arg.startsWith('--out=')) options.out = arg.slice('--out='.length);
+  }
+  return options;
+}
+
+function defaultComputerCardPath(cwd = process.cwd()) {
+  if (fs.existsSync(path.join(cwd, 'atris'))) {
+    return path.join(cwd, 'atris', 'reports', 'computer-card.md');
+  }
+  return path.join(cwd, 'computer-card.md');
+}
+
+function computerCard(args = [], cwd = process.cwd()) {
+  const options = parseComputerCardArgs(args);
+  if (options.help) {
+    console.log('Usage: atris computer card [--write] [--out <path>]');
+    console.log('');
+    console.log('Show the local owner/computer card for this workspace.');
+    return null;
+  }
+
+  const card = buildComputerCard(cwd);
+  console.log(renderComputerCard(card));
+
+  if (options.write || options.out) {
+    const outputPath = options.out
+      ? (path.isAbsolute(options.out) ? options.out : path.join(cwd, options.out))
+      : defaultComputerCardPath(cwd);
+    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+    fs.writeFileSync(outputPath, renderComputerCardMarkdown(card), 'utf8');
+    console.log('');
+    console.log(`Wrote ${path.relative(cwd, outputPath) || outputPath}`);
+    return outputPath;
+  }
+
+  return card;
+}
+
 async function resolveBusinessContext(token) {
   const binding = readBusinessBinding();
   if (!binding) return null;
@@ -2397,6 +2552,11 @@ async function runComputer() {
     return;
   }
 
+  if (sub === 'card') {
+    computerCard(args.slice(1));
+    return;
+  }
+
   if (sub === 'claude' || sub === 'codex') {
     computerLocalLegacy(args);
     return;
@@ -2405,6 +2565,15 @@ async function runComputer() {
   if (sub === '--help') {
     console.log('Usage: atris computer [mode|command]');
     console.log('');
+    console.log('Atris computers are persistent AI workspaces for scoped jobs.');
+    console.log('');
+    console.log('  Owner = User | Business');
+    console.log('  Owner has many Computers');
+    console.log('  Computer = workspace + files + tools + secrets + memory + agents + validation');
+    console.log('');
+    console.log('Common types: codeops, research, CRM, reporting, recruiting, event ops, support, business ops.');
+    console.log('A business can be a company, lab, collective, community, artist, team, or project.');
+    console.log('');
     console.log('First use:');
     console.log('  cd ~/arena/atris-business/<business>');
     console.log('  atris computer');
@@ -2412,6 +2581,7 @@ async function runComputer() {
     console.log('');
     console.log('Modes:');
     console.log('  (default)       Choose CLOUD vs LOCAL when both are available');
+    console.log('  card            Show the local owner/computer card, no login required');
     console.log('  local           Open LOCAL Atris mode; cloud brain edits this folder');
     console.log('  proof           Run the local-edit + cloud-isolation + audit proof');
     console.log('  local-byo       Open LOCAL BYO Claude mode; Anthropic tokens, no cloud audit');
@@ -2443,6 +2613,8 @@ async function runComputer() {
     console.log('');
     console.log('Examples:');
     console.log('  atris computer');
+    console.log('  atris computer card --write');
+    console.log('  atris business init "My Lab"     # shared owner + first/default computer');
     console.log('  atris computer proof');
     console.log('  atris computer local');
     console.log('  atris computer codex');
@@ -2522,6 +2694,7 @@ async function runComputer() {
 
   switch (sub) {
     case 'chat': return computerChat(token, ctx, cloudOptions);
+    case 'card': return computerCard(args.slice(1));
     case 'proof': return computerProof(token, ctx, cloudOptions);
     case 'status': return computerStatus(token, ctx);
     case 'wake': return computerWake(token, ctx);
@@ -2544,4 +2717,9 @@ async function runComputer() {
   }
 }
 
-module.exports = { runComputer };
+module.exports = {
+  runComputer,
+  buildComputerCard,
+  renderComputerCard,
+  renderComputerCardMarkdown,
+};

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,7 +700,8 @@ 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,

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;

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 };