create-arete-workspace 0.2.0

package/README.md

@@ -0,0 +1,77 @@
+# ARETE Starter
+
+AI Operating System — set up in 5 minutes.
+
+## Quick Start
+
+```bash
+npx create-arete-workspace
+```
+
+## What's Included
+
+- **Eve**: AI Chief of Staff (Telegram integration)
+- **Memory Bridge**: Auto-integrate knowledge across agents
+- **FORGE Workflow**: Coding agent + Impact Map
+- **Verify Loop**: Automatic implementation verification
+- **Tracer Agent**: Evidence-based bug causal tracking
+
+## 갓생OS
+
+Neuroscience-based habit & productivity dashboard powered by Obsidian.
+
+- **Dashboard**: Routines, goals, D-day, energy tracking, focus timer
+- **Obsidian Vault Backend**: All data stored as markdown with frontmatter
+- **Neuroscience Engine**: Ultradian rhythm scoring, habit stacking, Zeigarnik tracking
+- **Voice AI**: Eve voice assistant integration (OpenAI)
+- **Review System**: Weekly/monthly plan & retrospective
+
+```bash
+# Launch 갓생OS dashboard
+arete start
+```
+
+Runs on `http://localhost:3000` (Next.js dev server). Requires `VAULT_PATH` pointing to your Obsidian vault.
+
+## Architecture
+
+```
+Layer 1 (Framework) — updated via `arete update`
+├── scripts/          Session indexer, tracer, forge tools
+└── templates/        System templates
+
+Layer 2 (User Config) — NEVER auto-updated
+├── SOUL.md           Agent personality & behavior
+├── AGENTS.md         Agent routing & policies
+├── MEMORY.md         Persistent memory
+├── USER.md           User profile & preferences
+├── TOOLS.md          Local environment config
+├── HEARTBEAT.md      Health monitoring rules
+└── BOOTSTRAP.md      Session startup protocol
+```
+
+## Commands
+
+```bash
+# Initial setup
+npx create-arete-workspace
+
+# Check status
+arete status
+
+# Launch 갓생OS dashboard
+arete start
+
+# Update framework only (config files protected)
+arete update
+```
+
+## Update Safety
+
+`arete update` only touches Layer 1 files (scripts, templates). Your personal configuration files (SOUL.md, AGENTS.md, MEMORY.md, USER.md, etc.) are never modified during updates.
+
+## Requirements
+
+- Node.js 18+
+- Python 3.10+
+- macOS or Linux

package/bin/arete.js

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+
+import chalk from 'chalk';
+import { checkForUpdate, runUpdate } from '../lib/updater.js';
+import { execSync } from 'child_process';
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { resolve, join } from 'path';
+import { homedir } from 'os';
+
+const command = process.argv[2];
+
+async function cmdUpdate() {
+  console.log(chalk.blue('Checking for updates...'));
+  const result = await checkForUpdate();
+
+  if (!result.updateAvailable) {
+    console.log(chalk.green(`Already on latest version (${result.currentVersion})`));
+    return;
+  }
+
+  console.log(chalk.yellow(`Update available: ${result.currentVersion} → ${result.latestVersion}`));
+  console.log('');
+
+  await runUpdate(result.latestVersion);
+  console.log(chalk.green('Update complete!'));
+}
+
+function cmdStatus() {
+  console.log(chalk.bold('ARETE Status'));
+  console.log('');
+
+  // OpenClaw running?
+  let openclawRunning = false;
+  try {
+    const out = execSync('openclaw status', { stdio: 'pipe', timeout: 5000 }).toString();
+    openclawRunning = out.toLowerCase().includes('running');
+    console.log(`  OpenClaw: ${openclawRunning ? chalk.green('running') : chalk.yellow('stopped')}`);
+  } catch {
+    console.log(`  OpenClaw: ${chalk.red('not detected')}`);
+  }
+
+  // Workspace path
+  const workspacePath = resolve(homedir(), '.openclaw', 'workspace');
+  if (existsSync(workspacePath)) {
+    console.log(`  Workspace: ${chalk.dim(workspacePath)}`);
+  } else {
+    console.log(`  Workspace: ${chalk.red('not found')}`);
+    return;
+  }
+
+  // Agent count
+  const agentsDir = resolve(homedir(), '.openclaw', 'agents');
+  if (existsSync(agentsDir)) {
+    try {
+      const agents = readdirSync(agentsDir).filter((f) =>
+        statSync(join(agentsDir, f)).isDirectory()
+      );
+      console.log(`  Agents: ${chalk.bold(agents.length)}`);
+    } catch {
+      console.log(`  Agents: ${chalk.dim('unknown')}`);
+    }
+  }
+
+  // Last memory update
+  const memoryDir = resolve(workspacePath, 'memory');
+  if (existsSync(memoryDir)) {
+    try {
+      const files = readdirSync(memoryDir)
+        .filter((f) => f.endsWith('.md') && !f.startsWith('.'))
+        .sort()
+        .reverse();
+      if (files.length > 0) {
+        console.log(`  Last memory: ${chalk.dim(files[0])}`);
+      }
+    } catch {
+      console.log(`  Last memory: ${chalk.dim('unknown')}`);
+    }
+  }
+
+  // Package version
+  try {
+    const pkg = JSON.parse(
+      readFileSync(new URL('../package.json', import.meta.url), 'utf-8')
+    );
+    console.log(`  Version: ${chalk.dim(pkg.version)}`);
+  } catch {}
+
+  console.log('');
+}
+
+function cmdStart() {
+  const workspacePath = resolve(homedir(), '.openclaw', 'workspace');
+  const gatsaengDir = join(workspacePath, 'gatsaeng-os');
+
+  if (!existsSync(gatsaengDir)) {
+    console.log(chalk.red('갓생OS not found. Run create-arete-workspace with 갓생OS enabled.'));
+    process.exit(1);
+  }
+
+  const pkgJson = join(gatsaengDir, 'package.json');
+  if (!existsSync(pkgJson)) {
+    console.log(chalk.red('갓생OS package.json not found.'));
+    process.exit(1);
+  }
+
+  // Check if node_modules exists, install if not
+  if (!existsSync(join(gatsaengDir, 'node_modules'))) {
+    console.log(chalk.blue('Installing 갓생OS dependencies...'));
+    try {
+      execSync('npm install', { cwd: gatsaengDir, stdio: 'inherit' });
+    } catch {
+      console.log(chalk.red('Failed to install dependencies.'));
+      process.exit(1);
+    }
+  }
+
+  console.log(chalk.green('Starting 갓생OS...'));
+  console.log(chalk.dim(`  ${gatsaengDir}`));
+  console.log('');
+
+  try {
+    execSync('npm run dev', { cwd: gatsaengDir, stdio: 'inherit' });
+  } catch {
+    // User ctrl-c — normal exit
+  }
+}
+
+function showHelp() {
+  console.log('');
+  console.log(chalk.bold('  arete') + ' — ARETE workspace manager');
+  console.log('');
+  console.log('  Commands:');
+  console.log('    start     Launch 갓생OS dashboard');
+  console.log('    update    Update framework files (Layer 1 only)');
+  console.log('    status    Show workspace status');
+  console.log('    help      Show this help');
+  console.log('');
+}
+
+switch (command) {
+  case 'start':
+    cmdStart();
+    break;
+  case 'update':
+    cmdUpdate().catch((e) => {
+      console.error(chalk.red('Update failed: ' + e.message));
+      process.exit(1);
+    });
+    break;
+  case 'status':
+    cmdStatus();
+    break;
+  default:
+    showHelp();
+    break;
+}

package/bin/create.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+
+import { fileURLToPath } from 'url';
+import { dirname, resolve } from 'path';
+import chalk from 'chalk';
+import { checkEnvironment } from '../lib/install-openclaw.js';
+import { runWizard } from '../lib/setup-wizard.js';
+import { scaffold } from '../lib/scaffold.js';
+import { execSync } from 'child_process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const ROOT = resolve(__dirname, '..');
+
+const DRY_RUN = process.argv.includes('--dry-run');
+
+async function main() {
+  console.log('');
+  console.log(chalk.bold('  ARETE Workspace Setup'));
+  console.log(chalk.dim('  AI Operating System in 5 minutes'));
+  console.log('');
+
+  // Step 1: Environment check
+  console.log(chalk.blue('[1/5]') + ' Checking environment...');
+  const envOk = await checkEnvironment({ dryRun: DRY_RUN });
+  if (!envOk) {
+    process.exit(1);
+  }
+  console.log(chalk.green('  Environment OK'));
+  console.log('');
+
+  // Step 2: OpenClaw check
+  console.log(chalk.blue('[2/5]') + ' Checking OpenClaw...');
+  let openclawInstalled = false;
+  try {
+    execSync('openclaw --version', { stdio: 'pipe' });
+    openclawInstalled = true;
+    console.log(chalk.green('  OpenClaw found'));
+  } catch {
+    openclawInstalled = false;
+  }
+
+  if (!openclawInstalled) {
+    const { default: inquirer } = await import('inquirer');
+    const { install } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'install',
+        message: 'OpenClaw not found. Install now?',
+        default: true,
+      },
+    ]);
+    if (install) {
+      if (DRY_RUN) {
+        console.log(chalk.yellow('  [dry-run] Would run: npm install -g openclaw'));
+      } else {
+        console.log('  Installing OpenClaw...');
+        try {
+          execSync('npm install -g openclaw', { stdio: 'inherit' });
+          console.log(chalk.green('  OpenClaw installed'));
+        } catch (e) {
+          console.log(chalk.red('  Failed to install OpenClaw.'));
+          console.log(chalk.dim('  Try manually: npm install -g openclaw'));
+          process.exit(1);
+        }
+      }
+    } else {
+      console.log(chalk.red('  OpenClaw is required. Exiting.'));
+      process.exit(1);
+    }
+  }
+  console.log('');
+
+  // Step 3: Interactive wizard
+  console.log(chalk.blue('[3/5]') + ' Configuration...');
+  const config = await runWizard({ dryRun: DRY_RUN });
+  console.log('');
+
+  // Step 4: Scaffold workspace
+  console.log(chalk.blue('[4/5]') + ' Creating workspace...');
+  await scaffold({ config, templateDir: resolve(ROOT, 'templates'), dryRun: DRY_RUN });
+  console.log(chalk.green('  Workspace created at ' + config.workspacePath));
+  console.log('');
+
+  // Step 5: openclaw init
+  console.log(chalk.blue('[5/5]') + ' Registering with OpenClaw...');
+  if (DRY_RUN) {
+    console.log(chalk.yellow('  [dry-run] Would run: openclaw init in ' + config.workspacePath));
+  } else {
+    try {
+      execSync('openclaw init', { cwd: config.workspacePath, stdio: 'inherit' });
+    } catch {
+      console.log(chalk.yellow('  openclaw init skipped (may need manual setup)'));
+    }
+  }
+
+  // Done
+  console.log('');
+  console.log(chalk.green.bold('  ARETE workspace setup complete!'));
+  console.log('');
+  console.log('  Next steps:');
+  console.log(`    1. Find your bot on Telegram and send ${chalk.bold('/start')}`);
+  console.log(`    2. Run ${chalk.bold('openclaw start')}`);
+  console.log('    3. Send your first message');
+  console.log('');
+}
+
+main().catch((err) => {
+  console.error(chalk.red('Error: ' + err.message));
+  process.exit(1);
+});

package/lib/install-openclaw.js

@@ -0,0 +1,50 @@
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+
+export async function checkEnvironment({ dryRun = false } = {}) {
+  const errors = [];
+
+  // OS check
+  const platform = process.platform;
+  if (platform !== 'darwin' && platform !== 'linux') {
+    errors.push(`Unsupported OS: ${platform}. ARETE requires macOS or Linux.`);
+  }
+
+  // Node.js 18+
+  const nodeVersion = process.versions.node;
+  const major = parseInt(nodeVersion.split('.')[0], 10);
+  if (major < 18) {
+    errors.push(`Node.js ${nodeVersion} detected. ARETE requires Node.js 18+.`);
+    console.log(chalk.dim('  Install: https://nodejs.org/'));
+  } else {
+    console.log(chalk.dim(`  Node.js ${nodeVersion}`));
+  }
+
+  // Python 3.10+
+  try {
+    const pyVersion = execSync('python3 --version', { stdio: 'pipe' }).toString().trim();
+    const match = pyVersion.match(/Python (\d+)\.(\d+)/);
+    if (match) {
+      const pyMajor = parseInt(match[1], 10);
+      const pyMinor = parseInt(match[2], 10);
+      if (pyMajor < 3 || (pyMajor === 3 && pyMinor < 10)) {
+        errors.push(`${pyVersion} detected. ARETE requires Python 3.10+.`);
+      } else {
+        console.log(chalk.dim(`  ${pyVersion}`));
+      }
+    }
+  } catch {
+    errors.push('Python 3 not found. ARETE requires Python 3.10+.');
+    console.log(chalk.dim('  Install: https://www.python.org/downloads/'));
+  }
+
+  if (errors.length > 0) {
+    console.log('');
+    for (const err of errors) {
+      console.log(chalk.red('  ' + err));
+    }
+    return false;
+  }
+
+  return true;
+}

package/lib/scaffold.js

@@ -0,0 +1,213 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, cpSync } from 'fs';
+import { resolve, join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import chalk from 'chalk';
+
+function replaceVars(content, vars) {
+  let result = content;
+  for (const [key, value] of Object.entries(vars)) {
+    result = result.replaceAll(`{{${key}}}`, value);
+  }
+  return result;
+}
+
+function generateDomainAgentsTable(domains) {
+  if (!domains || domains.length === 0) return '(No domain agents configured)';
+  const rows = domains.map(
+    (d) => `| ${d} | ${d}-analyst sub-agent spawn |`
+  );
+  return `| Domain | Routing |\n|--------|--------|\n${rows.join('\n')}`;
+}
+
+function generateDomainAgentsConfig(domains) {
+  if (!domains || domains.length === 0) return '{}';
+  const config = {};
+  for (const d of domains) {
+    config[`${d}-analyst`] = { tag: d.charAt(0).toUpperCase() + d.slice(1), emoji: '📊' };
+  }
+  return JSON.stringify(config, null, 4);
+}
+
+export async function scaffold({ config, templateDir, dryRun = false }) {
+  const { name, telegramToken, agentName, domains, workspacePath, openclawPath } = config;
+
+  const vars = {
+    NAME: name,
+    AGENT_NAME: agentName,
+    TELEGRAM_TOKEN: telegramToken,
+    WORKSPACE_PATH: workspacePath,
+    OPENCLAW_PATH: openclawPath,
+    DOMAINS: domains.join(', '),
+    DOMAIN_AGENTS_TABLE: generateDomainAgentsTable(domains),
+    DOMAIN_AGENTS_CONFIG: generateDomainAgentsConfig(domains),
+  };
+
+  // Create workspace directories
+  const dirs = [
+    workspacePath,
+    join(workspacePath, 'memory'),
+    join(workspacePath, 'scripts'),
+    join(workspacePath, 'data'),
+    join(workspacePath, 'data', 'traces'),
+    join(workspacePath, 'ref'),
+  ];
+
+  for (const dir of dirs) {
+    if (dryRun) {
+      console.log(chalk.yellow(`  [dry-run] Would create dir: ${dir}`));
+    } else {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+
+  // Process workspace templates
+  const wsTemplateDir = join(templateDir, 'workspace');
+  if (existsSync(wsTemplateDir)) {
+    const templates = readdirSync(wsTemplateDir).filter((f) => f.endsWith('.tmpl'));
+    for (const tmpl of templates) {
+      const outputName = tmpl.replace('.tmpl', '');
+      const outputPath = join(workspacePath, outputName);
+      const content = readFileSync(join(wsTemplateDir, tmpl), 'utf-8');
+      const rendered = replaceVars(content, vars);
+
+      if (dryRun) {
+        console.log(chalk.yellow(`  [dry-run] Would write: ${outputPath}`));
+      } else {
+        writeFileSync(outputPath, rendered, 'utf-8');
+        console.log(chalk.dim(`  Created: ${outputName}`));
+      }
+    }
+  }
+
+  // Process script templates
+  const scriptTemplateDir = join(templateDir, 'scripts');
+  if (existsSync(scriptTemplateDir)) {
+    const scripts = readdirSync(scriptTemplateDir).filter((f) => f.endsWith('.tmpl'));
+    for (const tmpl of scripts) {
+      const outputName = tmpl.replace('.tmpl', '');
+      const outputPath = join(workspacePath, 'scripts', outputName);
+      const content = readFileSync(join(scriptTemplateDir, tmpl), 'utf-8');
+      const rendered = replaceVars(content, vars);
+
+      if (dryRun) {
+        console.log(chalk.yellow(`  [dry-run] Would write: ${outputPath}`));
+      } else {
+        writeFileSync(outputPath, rendered, 'utf-8');
+        console.log(chalk.dim(`  Created: scripts/${outputName}`));
+      }
+    }
+  }
+
+  // Create .env template
+  const envPath = join(workspacePath, '.env.example');
+  const envContent = `# ARETE Workspace Environment
+# Copy to .env and fill in your values
+TELEGRAM_BOT_TOKEN=your_token_here
+OPENAI_API_KEY=
+ANTHROPIC_API_KEY=
+`;
+
+  if (dryRun) {
+    console.log(chalk.yellow(`  [dry-run] Would write: ${envPath}`));
+  } else {
+    writeFileSync(envPath, envContent, 'utf-8');
+    console.log(chalk.dim('  Created: .env.example'));
+  }
+
+  // Create .gitignore
+  const gitignorePath = join(workspacePath, '.gitignore');
+  const gitignoreContent = `.env
+.env.*
+!.env.example
+node_modules/
+__pycache__/
+*.pyc
+.session_indexer_state.json
+`;
+
+  if (dryRun) {
+    console.log(chalk.yellow(`  [dry-run] Would write: ${gitignorePath}`));
+  } else {
+    writeFileSync(gitignorePath, gitignoreContent, 'utf-8');
+    console.log(chalk.dim('  Created: .gitignore'));
+  }
+
+  // 갓생OS scaffold
+  if (config.gatsaeng) {
+    await scaffoldGatsaeng({ config, dryRun });
+  }
+}
+
+export async function scaffoldGatsaeng({ config, dryRun = false }) {
+  const { workspacePath, vaultPath } = config;
+  const gatsaengDir = join(workspacePath, 'gatsaeng-os');
+
+  const __filename = fileURLToPath(import.meta.url);
+  const pkgRoot = resolve(dirname(__filename), '..');
+  const srcDir = join(pkgRoot, 'packages', 'gatsaeng-os');
+
+  if (!existsSync(srcDir)) {
+    console.log(chalk.red('  갓생OS source not found in package. Skipping.'));
+    return;
+  }
+
+  console.log(chalk.blue('  Setting up 갓생OS...'));
+
+  if (dryRun) {
+    console.log(chalk.yellow(`  [dry-run] Would copy 갓생OS to: ${gatsaengDir}`));
+    console.log(chalk.yellow(`  [dry-run] VAULT_PATH = ${vaultPath}`));
+    console.log(chalk.yellow(`  [dry-run] Would create Obsidian vault dirs in: ${vaultPath}`));
+    console.log(chalk.yellow('  [dry-run] Would run: npm install in gatsaeng-os/'));
+    return;
+  }
+
+  // Copy 갓생OS source
+  cpSync(srcDir, gatsaengDir, { recursive: true });
+  console.log(chalk.dim('  Copied 갓생OS source'));
+
+  // Create .env with VAULT_PATH
+  const envContent = `# 갓생OS Environment
+VAULT_PATH=${vaultPath}
+AUTH_USERNAME=admin
+AUTH_PASSWORD=changeme
+JWT_SECRET=${generateSecret()}
+`;
+  writeFileSync(join(gatsaengDir, '.env'), envContent, 'utf-8');
+  console.log(chalk.dim('  Created gatsaeng-os/.env'));
+
+  // Create Obsidian vault directories
+  const vaultDirs = [
+    vaultPath,
+    join(vaultPath, 'areas'),
+    join(vaultPath, 'goals'),
+    join(vaultPath, 'milestones'),
+    join(vaultPath, 'projects'),
+    join(vaultPath, 'tasks'),
+    join(vaultPath, 'routines'),
+    join(vaultPath, 'reviews'),
+    join(vaultPath, 'sessions'),
+    join(vaultPath, 'timing'),
+    join(vaultPath, 'books'),
+    join(vaultPath, 'calendar'),
+    join(vaultPath, 'notes'),
+    join(vaultPath, 'logs', 'routine'),
+    join(vaultPath, 'logs', 'energy'),
+    join(vaultPath, 'logs', 'focus'),
+  ];
+
+  for (const dir of vaultDirs) {
+    mkdirSync(dir, { recursive: true });
+  }
+  console.log(chalk.dim(`  Created Obsidian vault dirs at ${vaultPath}`));
+
+  console.log(chalk.green('  갓생OS ready — run `arete start` to launch'));
+}
+
+function generateSecret() {
+  const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+  let result = '';
+  for (let i = 0; i < 48; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return result;
+}

package/lib/setup-wizard.js

@@ -0,0 +1,88 @@
+import { resolve } from 'path';
+import { homedir } from 'os';
+
+export async function runWizard({ dryRun = false } = {}) {
+  if (dryRun) {
+    return {
+      name: 'TestUser',
+      telegramToken: 'dry-run-token',
+      agentName: 'Eve',
+      domains: ['invest', 'design'],
+      workspacePath: resolve(homedir(), 'arete-workspace'),
+      openclawPath: resolve(homedir(), '.openclaw'),
+      gatsaeng: true,
+      vaultPath: resolve(homedir(), 'Documents', 'Obsidian', 'GatsaengOS'),
+    };
+  }
+
+  const { default: inquirer } = await import('inquirer');
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'name',
+      message: 'Your name (English):',
+      validate: (v) => (v.trim().length > 0 ? true : 'Name is required'),
+    },
+    {
+      type: 'input',
+      name: 'telegramToken',
+      message: 'Telegram bot token:',
+      validate: (v) => (v.trim().length > 0 ? true : 'Token is required'),
+    },
+    {
+      type: 'input',
+      name: 'agentName',
+      message: 'Assistant name (default: Eve):',
+      default: 'Eve',
+    },
+    {
+      type: 'input',
+      name: 'domainsRaw',
+      message: 'Primary domains (comma-separated, e.g. invest, design, marketing):',
+      default: 'general',
+    },
+    {
+      type: 'input',
+      name: 'workspacePath',
+      message: `Workspace path (default: ${resolve(homedir(), 'arete-workspace')}):`,
+      default: resolve(homedir(), 'arete-workspace'),
+    },
+    {
+      type: 'confirm',
+      name: 'gatsaeng',
+      message: 'Install 갓생OS? (neuroscience-based habit & productivity dashboard)',
+      default: true,
+    },
+  ]);
+
+  let vaultPath = '';
+  if (answers.gatsaeng) {
+    const vaultAnswer = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'vaultPath',
+        message: 'Obsidian vault path for 갓생OS data:',
+        default: resolve(homedir(), 'Documents', 'Obsidian', 'GatsaengOS'),
+        validate: (v) => (v.trim().length > 0 ? true : 'Vault path is required for 갓생OS'),
+      },
+    ]);
+    vaultPath = resolve(vaultAnswer.vaultPath);
+  }
+
+  const domains = answers.domainsRaw
+    .split(',')
+    .map((d) => d.trim().toLowerCase())
+    .filter(Boolean);
+
+  return {
+    name: answers.name.trim(),
+    telegramToken: answers.telegramToken.trim(),
+    agentName: answers.agentName.trim(),
+    domains,
+    workspacePath: resolve(answers.workspacePath),
+    openclawPath: resolve(homedir(), '.openclaw'),
+    gatsaeng: answers.gatsaeng,
+    vaultPath,
+  };
+}