atris 2.6.3 → 3.0.1

package/commands/terminal.js

@@ -0,0 +1,201 @@
+/**
+ * atris terminal <business> <command...> [--timeout N]
+ *
+ * Run a shell command directly on a business EC2 workspace via the warm runner.
+ * This is the load-bearing primitive for fast bulk ops — one bash call beats
+ * hundreds of rate-limited individual file API calls.
+ *
+ * SAFETY:
+ * - Auto-wakes the EC2 computer (the rule: never operate on cache)
+ * - Refuses commands longer than 10000 chars (matches backend limit)
+ * - Caps timeout at 120s (matches backend limit)
+ * - Prints stdout, stderr, and exit_code so the caller knows what happened
+ *
+ * USAGE:
+ *   atris terminal pallet "ls /workspace/atris/"
+ *   atris terminal pallet "find /workspace -name '*.md' | wc -l" --timeout 60
+ *   atris terminal "rm -rf /workspace/cruft"   # auto-detects business from .atris/business.json
+ *
+ * Discovered the /terminal endpoint during overnight pallet cleanup — bulk
+ * deleting 401 files via individual /file DELETE calls hit the rate limit
+ * after request 60 and would have taken hours. One `rm -rf` via /terminal
+ * finished in 1 second.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { loadCredentials } = require('../utils/auth');
+const { apiRequestJson } = require('../utils/api');
+const { loadBusinesses, saveBusinesses } = require('./business');
+
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+async function ensureAwake(token, businessId, maxWaitSec = 90) {
+  const status = await apiRequestJson(`/business/${businessId}/ai-computer/status`, { method: 'GET', token });
+  if (status.ok && status.data && status.data.status === 'running' && status.data.endpoint) {
+    return true;
+  }
+  process.stdout.write('  Waking EC2 computer... ');
+  await apiRequestJson(`/business/${businessId}/ai-computer/wake`, { method: 'POST', token });
+  const start = Date.now();
+  while (Date.now() - start < maxWaitSec * 1000) {
+    await sleep(3000);
+    const s = await apiRequestJson(`/business/${businessId}/ai-computer/status`, { method: 'GET', token });
+    if (s.ok && s.data && s.data.status === 'running' && s.data.endpoint) {
+      const elapsed = Math.floor((Date.now() - start) / 1000);
+      console.log(`awake (${elapsed}s)`);
+      return true;
+    }
+  }
+  console.log('timeout');
+  return false;
+}
+
+async function resolveBusiness(token, slug) {
+  const businesses = loadBusinesses();
+  const list = await apiRequestJson('/business/', { method: 'GET', token });
+  if (list.ok) {
+    const match = (list.data || []).find(
+      (b) => b.slug === slug || b.name.toLowerCase() === slug.toLowerCase()
+    );
+    if (!match) return null;
+    businesses[slug] = {
+      business_id: match.id,
+      workspace_id: match.workspace_id,
+      name: match.name,
+      slug: match.slug,
+      added_at: new Date().toISOString(),
+    };
+    saveBusinesses(businesses);
+    return { businessId: match.id, workspaceId: match.workspace_id, businessName: match.name };
+  }
+  if (businesses[slug]) {
+    return {
+      businessId: businesses[slug].business_id,
+      workspaceId: businesses[slug].workspace_id,
+      businessName: businesses[slug].name || slug,
+    };
+  }
+  return null;
+}
+
+async function terminalAtris() {
+  // Parse args. Three forms:
+  //   atris terminal <business> <command...>
+  //   atris terminal <command...>          (auto-detect business)
+  //   atris terminal --help
+  const args = process.argv.slice(3);
+
+  if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+    console.log('Usage: atris terminal [business] <command> [--timeout N]');
+    console.log('');
+    console.log('  atris terminal pallet "ls /workspace/atris/"');
+    console.log('  atris terminal "find /workspace -name \\"*.md\\""    # auto-detect business');
+    console.log('  atris terminal pallet "rm -rf /workspace/cruft" --timeout 30');
+    console.log('');
+    console.log('  --timeout N    seconds to wait for the command (default 30, max 120)');
+    process.exit(0);
+  }
+
+  // Parse --timeout
+  let timeoutSec = 30;
+  const tIdx = args.indexOf('--timeout');
+  if (tIdx !== -1 && args[tIdx + 1]) {
+    const parsed = parseInt(args[tIdx + 1], 10);
+    if (!isNaN(parsed)) timeoutSec = Math.min(120, Math.max(1, parsed));
+    args.splice(tIdx, 2);
+  }
+
+  // Try to detect: if the first arg looks like a known slug (no quotes, no spaces),
+  // treat it as the business and the rest as the command.
+  // Otherwise auto-detect from .atris/business.json.
+  let slug = null;
+  let command = null;
+
+  const bizFile = path.join(process.cwd(), '.atris', 'business.json');
+  const cwdSlug = (() => {
+    if (!fs.existsSync(bizFile)) return null;
+    try { return JSON.parse(fs.readFileSync(bizFile, 'utf8')).slug; } catch { return null; }
+  })();
+
+  // If first arg is a single word with no shell metacharacters, it might be a slug
+  const firstLooksLikeSlug = args[0] && /^[a-z0-9-]+$/i.test(args[0]) && !args[0].includes(' ');
+
+  if (firstLooksLikeSlug && args.length > 1) {
+    slug = args[0];
+    command = args.slice(1).join(' ');
+  } else if (cwdSlug) {
+    slug = cwdSlug;
+    command = args.join(' ');
+  } else if (firstLooksLikeSlug && args.length === 1) {
+    // First (and only) arg is a slug-shaped word — could be the slug with no command
+    console.error('Missing command. Usage: atris terminal <business> <command>');
+    process.exit(1);
+  } else {
+    console.error('Cannot determine business. Run from inside a workspace, or pass slug as first arg.');
+    process.exit(1);
+  }
+
+  if (!command || command.length === 0) {
+    console.error('Missing command. Usage: atris terminal <business> <command>');
+    process.exit(1);
+  }
+  if (command.length > 10000) {
+    console.error(`Command too long (${command.length} chars, max 10000)`);
+    process.exit(1);
+  }
+
+  const creds = loadCredentials();
+  if (!creds || !creds.token) { console.error('Not logged in. Run: atris login'); process.exit(1); }
+
+  const biz = await resolveBusiness(creds.token, slug);
+  if (!biz) { console.error(`Business "${slug}" not found.`); process.exit(1); }
+  if (!biz.workspaceId) { console.error(`Business "${slug}" has no workspace.`); process.exit(1); }
+
+  // Auto-wake (the rule)
+  const awake = await ensureAwake(creds.token, biz.businessId);
+  if (!awake) {
+    console.error('  EC2 computer did not become ready in time. Aborting.');
+    process.exit(1);
+  }
+
+  // Execute the command
+  const result = await apiRequestJson(
+    `/business/${biz.businessId}/workspaces/${biz.workspaceId}/terminal`,
+    {
+      method: 'POST',
+      token: creds.token,
+      body: { command, timeout: timeoutSec },
+      timeoutMs: (timeoutSec + 10) * 1000,
+    }
+  );
+
+  if (!result.ok) {
+    console.error(`\n✗ Terminal call failed: ${result.errorMessage || result.error || result.status}`);
+    process.exit(1);
+  }
+
+  const body = result.data || {};
+  const stdout = body.stdout || '';
+  const stderr = body.stderr || '';
+  const exitCode = body.exit_code !== undefined ? body.exit_code : '?';
+  const timedOut = body.timed_out === true;
+
+  if (stdout) process.stdout.write(stdout);
+  if (stderr) {
+    if (stdout && !stdout.endsWith('\n')) process.stdout.write('\n');
+    process.stderr.write(stderr);
+    if (!stderr.endsWith('\n')) process.stderr.write('\n');
+  }
+
+  if (timedOut) {
+    console.error(`\n[timed out after ${timeoutSec}s]`);
+  }
+
+  // Exit with the same code as the remote command (so shell pipelines work)
+  process.exit(typeof exitCode === 'number' ? exitCode : 0);
+}
+
+module.exports = { terminalAtris };

package/commands/wiki.js

@@ -0,0 +1,376 @@
+const fs = require('fs');
+const path = require('path');
+const { loadCredentials } = require('../utils/auth');
+const { apiRequestJson } = require('../utils/api');
+const { loadBusinesses, saveBusinesses } = require('./business');
+const {
+  WIKI_ROOT,
+  ensureWikiScaffold,
+  findLocalWikiDir,
+  buildIngestPrompt,
+  buildQueryPrompt,
+  buildLintPrompt,
+} = require('../lib/wiki');
+
+function autoDetectSlug() {
+  const bizFile = path.join(process.cwd(), '.atris', 'business.json');
+  if (!fs.existsSync(bizFile)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(bizFile, 'utf8')).slug || null;
+  } catch {
+    return null;
+  }
+}
+
+function parseCloudArgs(args) {
+  if (args.length >= 2 && /^[a-z][a-z0-9-]*$/i.test(args[0])) {
+    return [args[0], args.slice(1).join(' ')];
+  }
+  return [autoDetectSlug(), args.join(' ')];
+}
+
+function parseModeArgs(args) {
+  const cloud = args.includes('--cloud');
+  return {
+    mode: cloud ? 'cloud' : 'local',
+    args: args.filter((arg) => arg !== '--cloud' && arg !== '--local'),
+  };
+}
+
+function requireCreds() {
+  const creds = loadCredentials();
+  if (!creds?.token) {
+    console.error('Not logged in. Run: atris login');
+    process.exit(1);
+  }
+  return creds;
+}
+
+async function resolveBusiness(slug, token) {
+  if (!slug) {
+    console.error('No business specified. Pass <slug> or run from a workspace folder.');
+    process.exit(1);
+  }
+
+  const cache = loadBusinesses();
+  const list = await apiRequestJson('/business/', { method: 'GET', token });
+  if (list.ok) {
+    const match = (list.data || []).find((business) => business.slug === slug || business.name?.toLowerCase() === slug.toLowerCase());
+    if (!match) {
+      console.error(`Business "${slug}" not found.`);
+      process.exit(1);
+    }
+    cache[slug] = {
+      business_id: match.id,
+      workspace_id: match.workspace_id,
+      name: match.name,
+      slug: match.slug,
+      added_at: new Date().toISOString(),
+    };
+    saveBusinesses(cache);
+    return match;
+  }
+
+  if (cache[slug]) {
+    return {
+      id: cache[slug].business_id,
+      workspace_id: cache[slug].workspace_id,
+      name: cache[slug].name || slug,
+    };
+  }
+
+  console.error(`Failed to reach API and no cached business for "${slug}".`);
+  process.exit(1);
+}
+
+async function runChat(business, prompt, token) {
+  const start = await apiRequestJson(`/business/${business.id}/chat`, {
+    method: 'POST',
+    token,
+    body: { message: prompt, workspace_id: business.workspace_id },
+  });
+
+  if (!start.ok) {
+    console.error(`Chat failed: ${start.error || start.status}`);
+    process.exit(1);
+  }
+
+  const executionId = start.data?.execution_id;
+  if (!executionId) {
+    console.error('No execution_id from server.');
+    process.exit(1);
+  }
+
+  let fromIndex = 0;
+  let errors = 0;
+  while (true) {
+    await new Promise((resolve) => setTimeout(resolve, 1500));
+    const events = await apiRequestJson(
+      `/business/${business.id}/chat/events?execution_id=${executionId}&workspace_id=${business.workspace_id}&from_index=${fromIndex}`,
+      { method: 'GET', token, timeoutMs: 60000 }
+    );
+
+    if (!events.ok) {
+      if (++errors >= 5) {
+        console.error('\nLost connection to AI computer.');
+        return;
+      }
+      continue;
+    }
+
+    errors = 0;
+    let done = false;
+    for (const event of (events.data?.events || [])) {
+      fromIndex++;
+      if (event.type === 'assistant_text' && event.content) {
+        process.stdout.write(event.content);
+      } else if (event.type === 'tool_use' && event.tool) {
+        const argument = event.input?.file_path || event.input?.path || event.input?.pattern || event.input?.command || '';
+        if (argument) {
+          console.log(`\n  [${event.tool}] ${String(argument).slice(0, 100)}`);
+        }
+      } else if (event.type === 'complete' || event.type === 'error') {
+        done = true;
+        break;
+      }
+    }
+
+    if (done || ['completed', 'error'].includes(events.data?.status)) {
+      console.log('');
+      return;
+    }
+  }
+}
+
+function printLocalPrompt(title, prompt, details = []) {
+  console.log('');
+  console.log(title);
+  console.log(`Target: ${WIKI_ROOT}`);
+  details.forEach((detail) => console.log(detail));
+  console.log('');
+  console.log('Prompt for the current coding agent:');
+  console.log('');
+  console.log(prompt);
+  console.log('');
+}
+
+async function wikiIngest(mode, slug, sourceValue) {
+  if (!sourceValue) {
+    console.error('Usage: atris wiki ingest [business] <path>');
+    process.exit(1);
+  }
+
+  if (mode === 'local') {
+    const wikiDir = ensureWikiScaffold();
+    printLocalPrompt('Local wiki ingest', buildIngestPrompt(sourceValue), [
+      `Wiki dir: ${wikiDir}`,
+      `Sources: ${sourceValue}`,
+    ]);
+    return;
+  }
+
+  const creds = requireCreds();
+  const business = await resolveBusiness(slug, creds.token);
+  console.log(`\nIngesting ${sourceValue} into ${business.name}...\n`);
+  await runChat(business, buildIngestPrompt(sourceValue), creds.token);
+  console.log('\nDone. Run `atris pull --only wiki` to sync atris/wiki locally.');
+}
+
+async function wikiQuery(mode, slug, question) {
+  if (!question) {
+    console.error('Usage: atris wiki query [business] "question"');
+    process.exit(1);
+  }
+
+  if (mode === 'local') {
+    const wikiDir = findLocalWikiDir(process.cwd(), slug);
+    if (!wikiDir) {
+      console.error('No local atris/wiki found. Run: atris ingest <path>');
+      process.exit(1);
+    }
+    printLocalPrompt('Local wiki query', buildQueryPrompt(question), [
+      `Wiki dir: ${wikiDir}`,
+      `Question: ${question}`,
+    ]);
+    return;
+  }
+
+  const creds = requireCreds();
+  const business = await resolveBusiness(slug, creds.token);
+  await runChat(business, buildQueryPrompt(question), creds.token);
+}
+
+async function wikiLint(mode, slug) {
+  if (mode === 'local') {
+    const wikiDir = findLocalWikiDir(process.cwd(), slug);
+    if (!wikiDir) {
+      console.error('No local atris/wiki found. Run: atris ingest <path>');
+      process.exit(1);
+    }
+    printLocalPrompt('Local wiki lint', buildLintPrompt(), [`Wiki dir: ${wikiDir}`]);
+    return;
+  }
+
+  const creds = requireCreds();
+  const business = await resolveBusiness(slug, creds.token);
+  console.log(`\nLinting ${business.name} wiki...\n`);
+  await runChat(business, buildLintPrompt(), creds.token);
+}
+
+function wikiSearch(slug, query) {
+  if (!query) {
+    console.error('Usage: atris wiki search [business] <term>');
+    process.exit(1);
+  }
+
+  const wikiDir = findLocalWikiDir(process.cwd(), slug);
+  if (!wikiDir) {
+    console.error(`No local wiki found. Run: atris pull ${slug || ''} --only wiki`);
+    process.exit(1);
+  }
+
+  const indexPath = path.join(wikiDir, 'index.md');
+  if (!fs.existsSync(indexPath)) {
+    console.error('No wiki index found. Run an ingest first.');
+    process.exit(1);
+  }
+
+  const lowered = query.toLowerCase();
+  const matches = fs.readFileSync(indexPath, 'utf8')
+    .split('\n')
+    .filter((line) => line.trim().startsWith('-') && line.toLowerCase().includes(lowered));
+
+  if (matches.length === 0) {
+    console.log(`No matches for "${query}".`);
+    return;
+  }
+
+  console.log(`\n${matches.length} match${matches.length === 1 ? '' : 'es'}:\n`);
+  matches.forEach((match) => console.log(match));
+  console.log('');
+}
+
+function wikiLog(slug, limit) {
+  const wikiDir = findLocalWikiDir(process.cwd(), slug);
+  if (!wikiDir) {
+    console.error(`No local wiki found. Run: atris pull ${slug || ''} --only wiki`);
+    process.exit(1);
+  }
+
+  const logPath = path.join(wikiDir, 'log.md');
+  if (!fs.existsSync(logPath)) {
+    console.log('No wiki log yet.');
+    return;
+  }
+
+  const lines = fs.readFileSync(logPath, 'utf8').split('\n');
+  const entries = lines.filter((line) => /^## \d{4}-\d{2}-\d{2}/.test(line) || /^- \d{1,2}:\d{2}/.test(line) || /^  - /.test(line));
+  if (entries.length === 0) {
+    console.log('No wiki log entries yet.');
+    return;
+  }
+
+  const output = [];
+  let bullets = 0;
+  let firstIndex = entries.length;
+  for (let index = entries.length - 1; index >= 0; index--) {
+    if (bullets >= limit && /^- /.test(entries[index])) break;
+    output.unshift(entries[index]);
+    firstIndex = index;
+    if (/^- /.test(entries[index])) bullets++;
+  }
+
+  if (output.length > 0 && !/^## /.test(output[0])) {
+    for (let index = firstIndex - 1; index >= 0; index--) {
+      if (/^## /.test(entries[index])) {
+        output.unshift(entries[index]);
+        break;
+      }
+    }
+  }
+
+  console.log('');
+  output.forEach((line) => console.log(line));
+  console.log('');
+}
+
+async function wikiCommand(subcommand, ...args) {
+  const { mode, args: cleanArgs } = parseModeArgs(args);
+
+  switch (subcommand) {
+    case 'ingest': {
+      const [slug, sourceValue] = mode === 'cloud' ? parseCloudArgs(cleanArgs) : [null, cleanArgs.join(' ')];
+      await wikiIngest(mode, slug, sourceValue);
+      break;
+    }
+    case 'query': {
+      const [slug, question] = mode === 'cloud' ? parseCloudArgs(cleanArgs) : [null, cleanArgs.join(' ')];
+      await wikiQuery(mode, slug, question);
+      break;
+    }
+    case 'lint': {
+      const slug = mode === 'cloud' ? (cleanArgs[0] || autoDetectSlug()) : null;
+      await wikiLint(mode, slug);
+      break;
+    }
+    case 'search': {
+      const [slug, query] = parseCloudArgs(cleanArgs);
+      wikiSearch(slug, query);
+      break;
+    }
+    case 'log': {
+      let slug;
+      let limit;
+      if (cleanArgs.length === 0) {
+        slug = autoDetectSlug();
+        limit = 20;
+      } else if (cleanArgs.length === 1) {
+        if (/^\d+$/.test(cleanArgs[0])) {
+          slug = autoDetectSlug();
+          limit = parseInt(cleanArgs[0], 10);
+        } else {
+          slug = cleanArgs[0];
+          limit = 20;
+        }
+      } else {
+        slug = cleanArgs[0];
+        limit = parseInt(cleanArgs[1], 10) || 20;
+      }
+      wikiLog(slug, limit);
+      break;
+    }
+    case 'loop': {
+      if (mode === 'cloud') {
+        console.error('Cloud loop is not implemented yet. Run local `atris loop` first.');
+        process.exit(1);
+      }
+      const { loopAtris } = require('./loop');
+      await loopAtris(cleanArgs);
+      break;
+    }
+    default:
+      console.log('Usage: atris wiki <ingest|query|lint|search|log|loop> [business] [args]');
+      console.log('');
+      console.log('  ingest <path>                 Local-first ingest into atris/wiki/');
+      console.log('  query  "question"             Local-first query against atris/wiki/');
+      console.log('  lint                          Local-first lint for atris/wiki/');
+      console.log('  search [business] <term>      Search local atris/wiki/index.md');
+      console.log('  log    [business] [N]         Show recent atris/wiki/log.md entries');
+      console.log('  loop                          Run local wiki upkeep analysis and refresh STATUS/log');
+      console.log('');
+      console.log('Flags:');
+      console.log('  --cloud                       Route ingest/query/lint to the cloud workspace');
+      console.log('  --local                       Be explicit about local mode');
+      console.log('');
+      console.log('Business is auto-detected from .atris/business.json for cloud mode if omitted.');
+  }
+}
+
+module.exports = {
+  wikiCommand,
+  wikiIngest,
+  wikiQuery,
+  wikiLint,
+  wikiSearch,
+  wikiLog,
+};