atris 2.5.2 → 2.5.4

package/commands/console.js

@@ -0,0 +1,397 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawn, spawnSync } = require('child_process');
+const readline = require('readline');
+
+// ── Context Gathering ──────────────────────────────────────────────
+
+function gatherAtrisContext(workspaceDir) {
+  const atrisDir = path.join(workspaceDir, 'atris');
+  const ctx = {
+    hasAtris: fs.existsSync(atrisDir),
+    skills: [],
+    teamMembers: [],
+    backlogCount: 0,
+    todayJournal: null,
+    persona: null,
+  };
+
+  if (!ctx.hasAtris) return ctx;
+
+  // Skills — scan atris/skills/ and .claude/skills/
+  for (const skillsRoot of [
+    path.join(atrisDir, 'skills'),
+    path.join(workspaceDir, '.claude', 'skills'),
+  ]) {
+    if (!fs.existsSync(skillsRoot)) continue;
+    for (const name of fs.readdirSync(skillsRoot)) {
+      const skillMd = path.join(skillsRoot, name, 'SKILL.md');
+      // Resolve symlinks
+      let resolvedPath = skillMd;
+      try {
+        const fullDir = path.join(skillsRoot, name);
+        const stat = fs.lstatSync(fullDir);
+        if (stat.isSymbolicLink()) {
+          resolvedPath = path.join(fs.realpathSync(fullDir), 'SKILL.md');
+        }
+      } catch {}
+      if (!fs.existsSync(resolvedPath)) continue;
+
+      // Extract name + description from frontmatter
+      try {
+        const raw = fs.readFileSync(resolvedPath, 'utf8');
+        const fmMatch = raw.match(/^---\n([\s\S]*?)\n---/);
+        let desc = name;
+        if (fmMatch) {
+          const descLine = fmMatch[1].match(/description:\s*(.+)/);
+          if (descLine) desc = descLine[1].trim();
+        }
+        ctx.skills.push({ name, description: desc, path: resolvedPath });
+      } catch {
+        ctx.skills.push({ name, description: name, path: resolvedPath });
+      }
+    }
+  }
+  // Dedupe by name
+  const seen = new Set();
+  ctx.skills = ctx.skills.filter(s => {
+    if (seen.has(s.name)) return false;
+    seen.add(s.name);
+    return true;
+  });
+
+  // Team members — scan atris/team/
+  const teamDir = path.join(atrisDir, 'team');
+  if (fs.existsSync(teamDir)) {
+    for (const name of fs.readdirSync(teamDir)) {
+      if (name.startsWith('_')) continue;
+      const memberMd = path.join(teamDir, name, 'MEMBER.md');
+      if (fs.existsSync(memberMd)) {
+        ctx.teamMembers.push(name);
+      }
+    }
+  }
+
+  // Backlog count from TODO.md
+  const todoFile = path.join(atrisDir, 'TODO.md');
+  if (fs.existsSync(todoFile)) {
+    const content = fs.readFileSync(todoFile, 'utf8');
+    const backlogMatch = content.match(/## Backlog\n([\s\S]*?)(?=\n## |$)/);
+    if (backlogMatch) {
+      ctx.backlogCount = (backlogMatch[1].match(/^- /gm) || []).length;
+    }
+  }
+
+  // Today's journal
+  const now = new Date();
+  const y = now.getFullYear();
+  const m = String(now.getMonth() + 1).padStart(2, '0');
+  const d = String(now.getDate()).padStart(2, '0');
+  const journalPath = path.join(atrisDir, 'logs', String(y), `${y}-${m}-${d}.md`);
+  if (fs.existsSync(journalPath)) {
+    ctx.todayJournal = journalPath;
+  }
+
+  // Persona
+  const personaPath = path.join(atrisDir, 'PERSONA.md');
+  if (fs.existsSync(personaPath)) {
+    ctx.persona = fs.readFileSync(personaPath, 'utf8').slice(0, 2000);
+  }
+
+  return ctx;
+}
+
+function buildSystemPrompt(ctx) {
+  const lines = [];
+
+  lines.push('# Atris Console');
+  lines.push('You are running inside the Atris Console — an AI workspace operating system.');
+  lines.push('');
+
+  if (ctx.persona) {
+    lines.push('## Persona');
+    lines.push(ctx.persona);
+    lines.push('');
+  }
+
+  if (ctx.teamMembers.length > 0) {
+    lines.push('## Team Members');
+    lines.push(`Available: ${ctx.teamMembers.join(', ')}`);
+    lines.push('Each has a MEMBER.md in atris/team/<name>/ defining their role.');
+    lines.push('');
+  }
+
+  if (ctx.skills.length > 0) {
+    lines.push('## Skills');
+    lines.push('Before replying, scan these skills. If one applies, read its SKILL.md then follow it.');
+    lines.push('');
+    for (const s of ctx.skills) {
+      lines.push(`- **${s.name}**: ${s.description} (${s.path})`);
+    }
+    lines.push('');
+  }
+
+  if (ctx.backlogCount > 0) {
+    lines.push(`## Current Work`);
+    lines.push(`${ctx.backlogCount} task${ctx.backlogCount > 1 ? 's' : ''} in backlog. Check atris/TODO.md for details.`);
+    lines.push('');
+  }
+
+  if (ctx.todayJournal) {
+    lines.push(`## Journal`);
+    lines.push(`Today's journal: ${ctx.todayJournal}`);
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+// ── TUI Rendering ──────────────────────────────────────────────────
+
+const COLORS = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  cyan: '\x1b[36m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  magenta: '\x1b[35m',
+  white: '\x1b[37m',
+  bgBlack: '\x1b[40m',
+  gray: '\x1b[90m',
+};
+
+function renderHeader(ctx, backend) {
+  const c = COLORS;
+  const width = Math.min(process.stdout.columns || 60, 70);
+  const line = '─'.repeat(width);
+
+  console.log('');
+  console.log(`${c.cyan}${c.bold}  ┌${line}┐${c.reset}`);
+  console.log(`${c.cyan}${c.bold}  │${''.padEnd(width)}│${c.reset}`);
+
+  // Title
+  const title = 'A T R I S   C O N S O L E';
+  const pad = Math.max(0, Math.floor((width - title.length) / 2));
+  console.log(`${c.cyan}${c.bold}  │${' '.repeat(pad)}${c.white}${title}${' '.repeat(width - pad - title.length)}${c.cyan}│${c.reset}`);
+
+  console.log(`${c.cyan}${c.bold}  │${''.padEnd(width)}│${c.reset}`);
+  console.log(`${c.cyan}  ├${line}┤${c.reset}`);
+
+  // Status row
+  const engine = `Engine: ${backend}`;
+  const skills = `Skills: ${ctx.skills.length}`;
+  const team = `Team: ${ctx.teamMembers.length}`;
+  const tasks = `Tasks: ${ctx.backlogCount}`;
+  const statusItems = [engine, skills, team, tasks].join('  │  ');
+  const statusPad = Math.max(0, Math.floor((width - statusItems.length) / 2));
+  console.log(`${c.cyan}  │${c.reset}${' '.repeat(statusPad)}${c.dim}${statusItems}${' '.repeat(Math.max(0, width - statusPad - statusItems.length))}${c.cyan}│${c.reset}`);
+
+  console.log(`${c.cyan}  └${line}┘${c.reset}`);
+  console.log('');
+}
+
+function renderSkillsBar(ctx) {
+  if (ctx.skills.length === 0) return;
+  const c = COLORS;
+  const names = ctx.skills.map(s => s.name).slice(0, 8);
+  console.log(`${c.dim}  Skills: ${names.map(n => `${c.magenta}/${n}${c.dim}`).join('  ')}${c.reset}`);
+  if (ctx.skills.length > 8) {
+    console.log(`${c.dim}  ... and ${ctx.skills.length - 8} more${c.reset}`);
+  }
+  console.log('');
+}
+
+// ── Backend Detection & Auth ───────────────────────────────────────
+
+function detectBackend(requested) {
+  const hasClaude = spawnSync('which', ['claude'], { stdio: 'pipe' }).status === 0;
+  const hasCodex = spawnSync('which', ['codex'], { stdio: 'pipe' }).status === 0;
+
+  if (requested) {
+    const installed = requested === 'claude' ? hasClaude : hasCodex;
+    if (!installed) return { backend: requested, installed: false, hasClaude, hasCodex };
+    return { backend: requested, installed: true, hasClaude, hasCodex };
+  }
+
+  if (hasClaude) return { backend: 'claude', installed: true, hasClaude, hasCodex };
+  if (hasCodex) return { backend: 'codex', installed: true, hasClaude, hasCodex };
+  return { backend: null, installed: false, hasClaude, hasCodex };
+}
+
+function offerInstall(target, callback) {
+  const pkg = target === 'claude'
+    ? '@anthropic-ai/claude-code'
+    : '@openai/codex';
+
+  console.log(`  ${target} is not installed.\n`);
+  if (target === 'claude') {
+    console.log('  Install: npm install -g @anthropic-ai/claude-code');
+    console.log('  Auth:    claude (follow login prompts)\n');
+  } else {
+    console.log('  Install: npm install -g @openai/codex');
+    console.log('  Auth:    export OPENAI_API_KEY=sk-...\n');
+  }
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  rl.question(`  Install ${target} now? (y/N) `, (answer) => {
+    rl.close();
+    if (answer.trim().toLowerCase() === 'y') {
+      console.log(`\n  Installing ${pkg}...\n`);
+      const install = spawnSync('npm', ['install', '-g', pkg], {
+        stdio: 'inherit',
+        env: process.env,
+      });
+      if (install.status !== 0) {
+        console.error(`\n✗ Install failed. Try: npm install -g ${pkg}`);
+        process.exit(1);
+      }
+      console.log(`\n✓ ${target} installed.\n`);
+      callback();
+    } else {
+      process.exit(0);
+    }
+  });
+}
+
+function checkAuth(backend) {
+  if (backend === 'claude') {
+    // Claude handles its own auth interactively — always allow
+    return true;
+  }
+  if (backend === 'codex') {
+    if (!process.env.OPENAI_API_KEY) {
+      console.error('\n  ✗ OPENAI_API_KEY not set.\n');
+      console.error('  Codex requires an OpenAI API key:');
+      console.error('    export OPENAI_API_KEY=sk-...\n');
+      console.error('  Get one at: https://platform.openai.com/api-keys\n');
+      process.exit(1);
+      return false;
+    }
+    return true;
+  }
+  return true;
+}
+
+// ── Launch ──────────────────────────────────────────────────────────
+
+function launchClaude(systemPrompt, extraArgs) {
+  const args = [
+    '--dangerously-skip-permissions',
+    '--append-system-prompt', systemPrompt,
+    ...extraArgs,
+  ];
+
+  const child = spawnSync('claude', args, {
+    cwd: process.cwd(),
+    stdio: 'inherit',
+    env: { ...process.env, CLAUDECODE: undefined },
+  });
+
+  if (child.error) {
+    console.error(`✗ Failed to start claude: ${child.error.message}`);
+    process.exit(1);
+  }
+  process.exit(child.status ?? 0);
+}
+
+function launchCodex(systemPrompt, extraArgs) {
+  // Codex uses ~/.codex/instructions.md for system instructions
+  // Write a temporary instructions file and point to it
+  const codexDir = path.join(os.homedir(), '.codex');
+  const instructionsPath = path.join(codexDir, 'instructions.md');
+
+  // Preserve existing instructions
+  let existingInstructions = '';
+  if (fs.existsSync(instructionsPath)) {
+    existingInstructions = fs.readFileSync(instructionsPath, 'utf8');
+  }
+
+  // Prepend Atris context
+  const combined = systemPrompt + '\n\n---\n\n' + existingInstructions;
+
+  // Write combined, launch, restore
+  if (!fs.existsSync(codexDir)) fs.mkdirSync(codexDir, { recursive: true });
+  fs.writeFileSync(instructionsPath, combined, 'utf8');
+
+  const child = spawnSync('codex', ['--full-auto', ...extraArgs], {
+    cwd: process.cwd(),
+    stdio: 'inherit',
+    env: process.env,
+  });
+
+  // Restore original
+  if (existingInstructions) {
+    fs.writeFileSync(instructionsPath, existingInstructions, 'utf8');
+  } else {
+    try { fs.unlinkSync(instructionsPath); } catch {}
+  }
+
+  if (child.error) {
+    console.error(`✗ Failed to start codex: ${child.error.message}`);
+    process.exit(1);
+  }
+  process.exit(child.status ?? 0);
+}
+
+// ── Main ────────────────────────────────────────────────────────────
+
+function consoleCommand() {
+  const args = process.argv.slice(3);
+  let requested = args[0];
+
+  if (requested === '--help' || requested === 'help') {
+    console.log('Usage: atris console [claude|codex] [...args]\n');
+    console.log('Launch a coding agent wrapped in Atris context.\n');
+    console.log('The console injects your team, skills, tasks, and persona');
+    console.log('into the agent session. Everything Atris knows, it knows.\n');
+    console.log('Examples:');
+    console.log('  atris console              Auto-detect and launch');
+    console.log('  atris console claude       Launch with Claude Code');
+    console.log('  atris console codex        Launch with Codex');
+    process.exit(0);
+  }
+
+  if (requested && !['claude', 'codex'].includes(requested)) {
+    console.error(`✗ Unknown backend: ${requested}`);
+    console.error('  Usage: atris console [claude|codex]');
+    process.exit(1);
+  }
+
+  const detection = detectBackend(requested);
+
+  function boot() {
+    const backend = detection.backend || 'claude';
+    checkAuth(backend);
+
+    // Gather Atris context
+    const ctx = gatherAtrisContext(process.cwd());
+
+    // Render TUI header
+    renderHeader(ctx, backend);
+    renderSkillsBar(ctx);
+
+    // Build system prompt
+    const systemPrompt = buildSystemPrompt(ctx);
+
+    // Extra args (skip backend name if it was first arg)
+    const extraArgs = requested === args[0] ? args.slice(1) : args;
+
+    // Launch
+    if (backend === 'claude') {
+      launchClaude(systemPrompt, extraArgs);
+    } else {
+      launchCodex(systemPrompt, extraArgs);
+    }
+  }
+
+  if (!detection.installed) {
+    const target = detection.backend || 'claude';
+    offerInstall(target, boot);
+  } else {
+    boot();
+  }
+}
+
+module.exports = { consoleCommand, gatherAtrisContext, buildSystemPrompt };

package/commands/experiments.js

@@ -0,0 +1,216 @@
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const ROOT_FILES = ['README.md', 'validate.py', 'benchmark_validate.py', 'benchmark_runtime.py'];
+const SUPPORT_DIRS = ['_fixtures', '_template', '_examples'];
+
+function ensureAtrisWorkspace(workspaceDir = process.cwd()) {
+  const atrisDir = path.join(workspaceDir, 'atris');
+  if (!fs.existsSync(atrisDir)) {
+    console.error('✗ Error: atris/ folder not found. Run "atris init" first.');
+    process.exit(1);
+  }
+  return atrisDir;
+}
+
+function copyRecursive(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (entry.name === '.DS_Store' || entry.name === '__pycache__') continue;
+
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyRecursive(srcPath, destPath);
+      continue;
+    }
+
+    if (!fs.existsSync(destPath)) {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function ensureExperimentsFramework(workspaceDir = process.cwd(), { silent = false } = {}) {
+  const atrisDir = ensureAtrisWorkspace(workspaceDir);
+  const packageExperimentsDir = path.join(__dirname, '..', 'atris', 'experiments');
+  const experimentsDir = path.join(atrisDir, 'experiments');
+  const created = [];
+
+  if (!fs.existsSync(experimentsDir)) {
+    fs.mkdirSync(experimentsDir, { recursive: true });
+    created.push('atris/experiments/');
+  }
+
+  for (const file of ROOT_FILES) {
+    const src = path.join(packageExperimentsDir, file);
+    const dest = path.join(experimentsDir, file);
+    if (!fs.existsSync(dest) && fs.existsSync(src)) {
+      fs.copyFileSync(src, dest);
+      created.push(`atris/experiments/${file}`);
+    }
+  }
+
+  for (const dirName of SUPPORT_DIRS) {
+    const src = path.join(packageExperimentsDir, dirName);
+    const dest = path.join(experimentsDir, dirName);
+    if (fs.existsSync(src)) {
+      const hadDest = fs.existsSync(dest);
+      copyRecursive(src, dest);
+      if (!hadDest) {
+        created.push(`atris/experiments/${dirName}/`);
+      }
+    }
+  }
+
+  if (!silent) {
+    if (created.length > 0) {
+      console.log(`✓ Prepared atris/experiments/ (${created.length} item${created.length === 1 ? '' : 's'})`);
+    } else {
+      console.log('✓ atris/experiments/ already ready');
+    }
+  }
+
+  return { atrisDir, experimentsDir, created };
+}
+
+function resolvePython() {
+  const candidates = [
+    process.env.ATRIS_EXPERIMENTS_PYTHON,
+    'python3',
+    'python',
+  ].filter(Boolean);
+
+  for (const candidate of candidates) {
+    const probe = spawnSync(candidate, ['--version'], { encoding: 'utf8' });
+    if (!probe.error && probe.status === 0) {
+      return candidate;
+    }
+  }
+
+  return null;
+}
+
+function runPython(scriptPath, args = [], cwd = process.cwd()) {
+  const python = resolvePython();
+  if (!python) {
+    console.error('✗ Error: Python not found. Set ATRIS_EXPERIMENTS_PYTHON or install python3.');
+    process.exit(1);
+  }
+
+  const result = spawnSync(python, [scriptPath, ...args], {
+    cwd,
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      PYTHONDONTWRITEBYTECODE: '1',
+    },
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  if (typeof result.status === 'number' && result.status !== 0) {
+    process.exit(result.status);
+  }
+}
+
+function experimentsInit(name) {
+  const { experimentsDir } = ensureExperimentsFramework();
+
+  if (!name) {
+    console.log('');
+    console.log('Experiments framework ready.');
+    console.log('Next: atris experiments init <slug>');
+    console.log('');
+    return;
+  }
+
+  if (!SLUG_RE.test(name)) {
+    console.error('✗ Invalid experiment name. Use lowercase-hyphen slug, for example: self-heal');
+    process.exit(1);
+  }
+
+  const targetDir = path.join(experimentsDir, name);
+  if (fs.existsSync(targetDir)) {
+    console.error(`✗ Experiment "${name}" already exists at atris/experiments/${name}/`);
+    process.exit(1);
+  }
+
+  const templateDir = path.join(experimentsDir, '_template', 'pack');
+  copyRecursive(templateDir, targetDir);
+
+  console.log(`✓ Created atris/experiments/${name}/`);
+  console.log('  Files: program.md, measure.py, loop.py, results.tsv, reset.py');
+}
+
+function experimentsValidate(rootArg) {
+  const { experimentsDir } = ensureExperimentsFramework();
+  const args = [];
+
+  if (rootArg) {
+    args.push(rootArg);
+  }
+
+  runPython(path.join(experimentsDir, 'validate.py'), args, experimentsDir);
+}
+
+function experimentsBenchmark(kind = 'all') {
+  const { experimentsDir } = ensureExperimentsFramework();
+  const modes = kind === 'all' ? ['validate', 'runtime'] : [kind];
+
+  for (const mode of modes) {
+    if (mode === 'validate') {
+      console.log('Running experiment validator benchmark...');
+      runPython(path.join(experimentsDir, 'benchmark_validate.py'), [], experimentsDir);
+      continue;
+    }
+
+    if (mode === 'runtime') {
+      console.log('Running experiment runtime benchmark...');
+      runPython(path.join(experimentsDir, 'benchmark_runtime.py'), [], experimentsDir);
+      continue;
+    }
+
+    console.error('Usage: atris experiments benchmark [validate|runtime|all]');
+    process.exit(1);
+  }
+}
+
+function experimentsCommand(subcommand, ...args) {
+  switch (subcommand) {
+    case 'init':
+    case 'new':
+      return experimentsInit(args[0]);
+    case 'validate':
+      return experimentsValidate(args[0]);
+    case 'benchmark':
+      return experimentsBenchmark(args[0] || 'all');
+    default:
+      console.log('');
+      console.log('Usage: atris experiments <subcommand> [name]');
+      console.log('');
+      console.log('Subcommands:');
+      console.log('  init [slug]          Prepare atris/experiments/ or scaffold a new pack');
+      console.log('  validate [path|slug] Run structural validation on packs or a single pack');
+      console.log('  benchmark [mode]     Run validate/runtime/all benchmark harness');
+      console.log('');
+      console.log('Examples:');
+      console.log('  atris experiments init');
+      console.log('  atris experiments init self-heal');
+      console.log('  atris experiments validate');
+      console.log('  atris experiments benchmark runtime');
+      console.log('');
+  }
+}
+
+module.exports = {
+  experimentsCommand,
+  ensureExperimentsFramework,
+};

package/commands/init.js

@@ -1,5 +1,6 @@
 const fs = require('fs');
 const path = require('path');
+const { ensureExperimentsFramework } = require('./experiments');
 
 /**
  * Detect project context by scanning project structure
@@ -474,6 +475,9 @@ function initAtris() {
     console.log(`✓ Created features/_templates/${name} (fallback)`);
   });
 
+  // Create experiments directory and packaged validation harness
+  ensureExperimentsFramework(process.cwd(), { silent: false });
+
 
   // Copy team members (MEMBER.md format — directory per member with skills/tools/context)
   const members = ['navigator', 'executor', 'validator', 'launcher', 'brainstormer', 'researcher'];