pluribus-cli 0.1.0

package/bin/pluribus.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import { printBanner } from '../src/utils/banner.js';
+import { importAgent } from '../src/commands/import.js';
+import { registerAgent } from '../src/commands/register.js';
+import { initAgent } from '../src/commands/init.js';
+import { deployAgent } from '../src/commands/deploy.js';
+import { listAgents } from '../src/commands/list.js';
+import { networkStatus } from '../src/commands/status.js';
+import { submitTask } from '../src/commands/submit.js';
+import { stake, unstake } from '../src/commands/stake.js';
+import { balance } from '../src/commands/balance.js';
+import { logs } from '../src/commands/logs.js';
+import { configCmd } from '../src/commands/config.js';
+
+program
+  .name('pluribus')
+  .description('Pluribus CLI — Many Agents. One Mind.')
+  .version('0.1.0', '-v, --version', 'Show CLI version')
+  .addHelpText('beforeAll', () => {
+    printBanner();
+    return '';
+  });
+
+// ─── import ─────────────────────────────────────────────────────────────────
+program
+  .command('import [agent-id]')
+  .description('Import an existing agent into the Pluribus network')
+  .option('-p, --platform <platform>', 'Agent framework (virtuals, eliza, langchain, etc.)')
+  .option('-s, --stake <amount>', '$PLUR to stake')
+  .action(importAgent);
+
+// ─── register ───────────────────────────────────────────────────────────────
+program
+  .command('register')
+  .description('Register a new agent and stake $PLUR to join the network')
+  .option('-n, --name <name>', 'Agent name')
+  .option('-e, --endpoint <url>', 'Webhook endpoint URL')
+  .action(registerAgent);
+
+// ─── init ────────────────────────────────────────────────────────────────────
+program
+  .command('init [name]')
+  .description('Scaffold a new Pluribus agent project')
+  .option('-t, --template <template>', 'Starter template (default, research, social, onchain)')
+  .action(initAgent);
+
+// ─── deploy ──────────────────────────────────────────────────────────────────
+program
+  .command('deploy')
+  .description('Deploy your agent to the Pluribus network')
+  .option('-c, --config <path>', 'Path to pluribus.config.json', 'pluribus.config.json')
+  .action(deployAgent);
+
+// ─── list ─────────────────────────────────────────────────────────────────────
+program
+  .command('list')
+  .alias('ls')
+  .description('List agents registered on the network')
+  .option('-t, --type <type>', 'Filter by capability type')
+  .option('--mine', 'Show only your registered agents')
+  .action(listAgents);
+
+// ─── status ──────────────────────────────────────────────────────────────────
+program
+  .command('status')
+  .description('Show Pluribus network and protocol status')
+  .action(networkStatus);
+
+// ─── submit ──────────────────────────────────────────────────────────────────
+program
+  .command('submit [task]')
+  .description('Submit a task to the Pluribus agent network')
+  .option('-t, --type <type>', 'Task type (research, social, monitoring, onchain, auto)')
+  .option('-p, --plur <amount>', '$PLUR payment for the task', '0.5')
+  .action(submitTask);
+
+// ─── stake ───────────────────────────────────────────────────────────────────
+program
+  .command('stake [amount]')
+  .description('Stake $PLUR to earn yield from network task fees')
+  .option('-w, --wallet <address>', 'Wallet address')
+  .option('--tier <tier>', 'Staking tier (sentinel, archon, sovereign)')
+  .action(stake);
+
+// ─── unstake ─────────────────────────────────────────────────────────────────
+program
+  .command('unstake [amount]')
+  .description('Unstake $PLUR from the network')
+  .option('-w, --wallet <address>', 'Wallet address')
+  .action(unstake);
+
+// ─── balance ─────────────────────────────────────────────────────────────────
+program
+  .command('balance [address]')
+  .description('Check $PLUR balance for a wallet address')
+  .action(balance);
+
+// ─── logs ─────────────────────────────────────────────────────────────────────
+program
+  .command('logs [agent-id]')
+  .description('Stream live logs from an agent or task')
+  .option('-f, --follow', 'Follow log output in real time')
+  .option('-n, --lines <n>', 'Number of recent lines to show', '50')
+  .action(logs);
+
+// ─── config ───────────────────────────────────────────────────────────────────
+program
+  .command('config [action]')
+  .description('Manage CLI configuration (show | set | reset)')
+  .action(configCmd);
+
+// Default: show banner + help if no command
+if (process.argv.length === 2) {
+  printBanner();
+  program.outputHelp();
+  process.exit(0);
+}
+
+program.parse();

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "pluribus-cli",
+  "version": "0.1.0",
+  "description": "Pluribus CLI — Register, manage, and deploy AI agents on the Pluribus multi-agent coordination protocol",
+  "type": "module",
+  "bin": {
+    "pluribus": "./bin/pluribus.js"
+  },
+  "scripts": {
+    "start": "node bin/pluribus.js"
+  },
+  "keywords": ["pluribus", "ai", "agents", "base", "web3", "cli", "multi-agent"],
+  "author": "Pluribus Protocol",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "inquirer": "^13.3.0",
+    "ora": "^9.3.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/commands/balance.js

@@ -0,0 +1,50 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { label, printDivider, info, warn } from '../utils/banner.js';
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+export async function balance(address, options) {
+  const inquirer = (await import('inquirer')).default;
+
+  console.log('');
+  console.log(chalk.cyan.bold('  → $PLUR Balance'));
+  console.log('');
+
+  if (!address) {
+    const answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'address',
+        message: chalk.white('Wallet address (0x...):'),
+        prefix: chalk.cyan(' ▸'),
+        validate: v => v.startsWith('0x') && v.length === 42 ? true : 'Enter a valid Ethereum address',
+      },
+    ]);
+    address = answers.address;
+  }
+
+  console.log('');
+  const spinner = ora({ text: chalk.dim('Querying Base network...'), spinner: 'dots', color: 'cyan' }).start();
+  await sleep(900);
+  spinner.succeed(chalk.green('Balance retrieved'));
+
+  console.log('');
+  console.log(chalk.cyan.bold('  Wallet'));
+  printDivider();
+  label('Address:', address);
+  label('Network:', 'Base Mainnet');
+  console.log('');
+
+  console.log(chalk.cyan.bold('  $PLUR Balance'));
+  printDivider();
+  label('Available:', chalk.cyan('— (token not yet launched)'));
+  label('Staked:', chalk.cyan('—'));
+  label('Earned:', chalk.cyan('—'));
+  label('Total:', chalk.cyan('—'));
+  console.log('');
+
+  warn('$PLUR launches with the Pluribus network. Stay tuned.');
+  info(`Track launch: ${chalk.underline('https://pluribus.xyz')}`);
+  console.log('');
+}

package/src/commands/config.js

@@ -0,0 +1,108 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { label, printDivider, info, success } from '../utils/banner.js';
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+const CONFIG_PATH = path.join(os.homedir(), '.pluribus', 'config.json');
+
+function loadConfig() {
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+  } catch {
+    return {
+      rpcUrl: 'https://mainnet.base.org',
+      wallet: '',
+      apiKey: '',
+      network: 'base-mainnet',
+    };
+  }
+}
+
+function saveConfig(cfg) {
+  fs.mkdirSync(path.dirname(CONFIG_PATH), { recursive: true });
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2));
+}
+
+export async function configCmd(action, options) {
+  const inquirer = (await import('inquirer')).default;
+
+  console.log('');
+  console.log(chalk.cyan.bold('  → CLI Configuration'));
+  console.log('');
+
+  const cfg = loadConfig();
+
+  if (action === 'show' || !action) {
+    console.log(chalk.cyan.bold('  Current Configuration'));
+    printDivider();
+    label('Config file:', CONFIG_PATH);
+    label('Network:', cfg.network || 'base-mainnet');
+    label('RPC URL:', cfg.rpcUrl || chalk.dim('not set'));
+    label('Wallet:', cfg.wallet || chalk.dim('not set'));
+    label('API Key:', cfg.apiKey ? chalk.green('● set') : chalk.dim('not set'));
+    console.log('');
+    return;
+  }
+
+  if (action === 'set') {
+    const answers = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'network',
+        message: chalk.white('Network:'),
+        prefix: chalk.cyan(' ▸'),
+        choices: [
+          { name: 'Base Mainnet', value: 'base-mainnet' },
+          { name: 'Base Sepolia (testnet)', value: 'base-sepolia' },
+        ],
+        default: cfg.network,
+      },
+      {
+        type: 'input',
+        name: 'rpcUrl',
+        message: chalk.white('RPC URL:'),
+        prefix: chalk.cyan(' ▸'),
+        default: cfg.rpcUrl || 'https://mainnet.base.org',
+      },
+      {
+        type: 'input',
+        name: 'wallet',
+        message: chalk.white('Default wallet address (0x...):'),
+        prefix: chalk.cyan(' ▸'),
+        default: cfg.wallet,
+      },
+      {
+        type: 'password',
+        name: 'apiKey',
+        message: chalk.white('Pluribus API key (leave blank to skip):'),
+        prefix: chalk.cyan(' ▸'),
+        mask: '●',
+      },
+    ]);
+
+    const newCfg = {
+      network: answers.network,
+      rpcUrl: answers.rpcUrl,
+      wallet: answers.wallet,
+      apiKey: answers.apiKey || cfg.apiKey,
+    };
+
+    const spinner = ora({ text: chalk.dim('Saving configuration...'), spinner: 'dots', color: 'cyan' }).start();
+    await sleep(400);
+    saveConfig(newCfg);
+    spinner.succeed(chalk.green('Configuration saved'));
+    console.log('');
+    label('Saved to:', CONFIG_PATH);
+    console.log('');
+
+  } else if (action === 'reset') {
+    const defaultCfg = { rpcUrl: 'https://mainnet.base.org', wallet: '', apiKey: '', network: 'base-mainnet' };
+    saveConfig(defaultCfg);
+    success('Configuration reset to defaults.');
+    console.log('');
+  }
+}

package/src/commands/deploy.js

@@ -0,0 +1,58 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'fs';
+import { label, printDivider, warn, info, success, error } from '../utils/banner.js';
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+export async function deployAgent(options) {
+  console.log('');
+  console.log(chalk.cyan.bold('  → Deploy Agent'));
+  console.log(chalk.dim('    Deploy your agent to the Pluribus network'));
+  console.log('');
+
+  // Check for pluribus.config.json
+  if (!fs.existsSync('pluribus.config.json')) {
+    error('No pluribus.config.json found in current directory.');
+    info(`Run ${chalk.cyan('pluribus init')} to scaffold a new agent, or navigate to your agent directory.`);
+    console.log('');
+    process.exit(1);
+  }
+
+  let config;
+  try {
+    config = JSON.parse(fs.readFileSync('pluribus.config.json', 'utf8'));
+  } catch {
+    error('Invalid pluribus.config.json — check JSON syntax.');
+    process.exit(1);
+  }
+
+  console.log(chalk.cyan.bold('  Deployment Config'));
+  printDivider();
+  label('Agent Name:', config.name || '—');
+  label('Version:', config.version || '0.1.0');
+  label('Capabilities:', (config.capabilities || []).join(', '));
+  label('Endpoint:', config.endpoint || '—');
+  label('Network:', config.network || 'base-mainnet');
+  label('Stake Tier:', config.stake?.tier || '—');
+  console.log('');
+
+  const spinner = ora({ text: chalk.dim('Validating configuration...'), spinner: 'dots', color: 'cyan' }).start();
+  await sleep(700);
+  spinner.text = chalk.dim('Checking endpoint health...');
+  await sleep(600);
+  spinner.text = chalk.dim('Verifying stake requirements...');
+  await sleep(500);
+  spinner.text = chalk.dim('Staging on-chain deployment...');
+  await sleep(800);
+  spinner.succeed(chalk.green('Deployment staged'));
+
+  console.log('');
+  label('Status:', chalk.yellow('Staged — pending network launch'));
+  label('Estimated Launch:', chalk.cyan('Soon™'));
+  console.log('');
+
+  warn('Deployment will execute when the Pluribus network goes live on Base.');
+  info(`Monitor status: ${chalk.cyan('pluribus status')}`);
+  console.log('');
+}

package/src/commands/import.js

@@ -0,0 +1,128 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { createRequire } from 'module';
+import { success, error, info, warn, label, printDivider } from '../utils/banner.js';
+
+export async function importAgent(agentId, options) {
+  const { select, input, confirm } = await import('@inquirer/prompts').catch(() => {
+    return import('inquirer').then(m => m.default.prompt ? { select: null, input: null, confirm: null } : {});
+  }).catch(() => ({ select: null, input: null, confirm: null }));
+
+  console.log('');
+  console.log(chalk.cyan.bold('  → Import Agent into Pluribus'));
+  console.log(chalk.dim('    Connect an existing agent to the network'));
+  console.log('');
+
+  if (!agentId) {
+    // Interactive mode
+    const inquirer = (await import('inquirer')).default;
+
+    const answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'agentId',
+        message: chalk.white('Agent ID or endpoint URL:'),
+        prefix: chalk.cyan(' ▸'),
+        validate: v => v.length > 0 ? true : 'Agent ID is required',
+      },
+      {
+        type: 'list',
+        name: 'platform',
+        message: chalk.white('Agent framework:'),
+        prefix: chalk.cyan(' ▸'),
+        choices: [
+          { name: 'Virtuals Protocol', value: 'virtuals' },
+          { name: 'ElizaOS', value: 'eliza' },
+          { name: 'LangChain', value: 'langchain' },
+          { name: 'AutoGPT', value: 'autogpt' },
+          { name: 'CrewAI', value: 'crewai' },
+          { name: 'Custom / Other', value: 'custom' },
+        ],
+      },
+      {
+        type: 'checkbox',
+        name: 'capabilities',
+        message: chalk.white('Declare capabilities:'),
+        prefix: chalk.cyan(' ▸'),
+        choices: [
+          { name: 'Research & Analysis', value: 'research' },
+          { name: 'Social Media', value: 'social' },
+          { name: 'Onchain Execution', value: 'onchain' },
+          { name: 'Wallet Monitoring', value: 'monitoring' },
+          { name: 'Content Generation', value: 'content' },
+          { name: 'Data Retrieval', value: 'data' },
+        ],
+        validate: v => v.length > 0 ? true : 'Select at least one capability',
+      },
+      {
+        type: 'input',
+        name: 'stakeAmount',
+        message: chalk.white('$PLUR to stake (minimum required to join):'),
+        prefix: chalk.cyan(' ▸'),
+        default: '1000',
+        validate: v => !isNaN(Number(v)) && Number(v) > 0 ? true : 'Enter a valid amount',
+      },
+    ]);
+
+    agentId = answers.agentId;
+
+    console.log('');
+    printDivider();
+    console.log('');
+
+    const spinner = ora({
+      text: chalk.dim('Verifying agent endpoint...'),
+      spinner: 'dots',
+      color: 'cyan',
+    }).start();
+
+    await sleep(1200);
+    spinner.text = chalk.dim('Checking stake requirements...');
+    await sleep(800);
+    spinner.text = chalk.dim('Validating capabilities...');
+    await sleep(700);
+    spinner.succeed(chalk.green('Agent verified'));
+
+    console.log('');
+    console.log(chalk.cyan.bold('  Registration Preview'));
+    printDivider();
+    label('Agent ID:', agentId);
+    label('Platform:', answers.platform);
+    label('Capabilities:', answers.capabilities.join(', '));
+    label('Stake Amount:', `${Number(answers.stakeAmount).toLocaleString()} $PLUR`);
+    label('Status:', chalk.yellow('Pending — awaiting mainnet launch'));
+    console.log('');
+
+    warn('Mainnet launch is coming soon. Your agent config has been saved locally.');
+    info('Run ' + chalk.cyan('pluribus list') + ' to view your staged agents.');
+    info('Run ' + chalk.cyan('pluribus deploy') + ' once the network is live.');
+    console.log('');
+
+  } else {
+    // Direct import with ID
+    const spinner = ora({
+      text: chalk.dim(`Importing agent ${chalk.cyan(agentId)}...`),
+      spinner: 'dots',
+      color: 'cyan',
+    }).start();
+
+    await sleep(900);
+    spinner.text = chalk.dim('Resolving agent metadata...');
+    await sleep(700);
+    spinner.text = chalk.dim('Staging registration...');
+    await sleep(600);
+    spinner.succeed(chalk.green(`Agent ${chalk.cyan(agentId)} staged for import`));
+
+    console.log('');
+    label('Agent ID:', agentId);
+    label('Network:', 'Base (Mainnet)');
+    label('Status:', chalk.yellow('Staged — deploy when network launches'));
+    console.log('');
+    info(`Run ${chalk.cyan('pluribus deploy')} once the Pluribus network goes live.`);
+    console.log('');
+  }
+}
+
+function sleep(ms) {
+  return new Promise(r => setTimeout(r, ms));
+}

package/src/commands/init.js

@@ -0,0 +1,220 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'fs';
+import path from 'path';
+import { success, info, warn, label, printDivider } from '../utils/banner.js';
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+const AGENT_TEMPLATE = (name, capabilities) => `import { PluribusAgent } from '@pluribus/agent-sdk';
+
+/**
+ * ${name} — Pluribus Agent
+ * Capabilities: ${capabilities.join(', ')}
+ *
+ * Docs: https://pluribus.xyz/docs/sdk
+ */
+const agent = new PluribusAgent({
+  name: '${name}',
+  capabilities: ${JSON.stringify(capabilities)},
+  version: '0.1.0',
+});
+
+// Handle incoming tasks routed by the Pluribus orchestrator
+agent.on('task', async (task) => {
+  const { id, type, payload, respond } = task;
+
+  console.log(\`Received task \${id} of type \${type}\`);
+
+  // TODO: Implement your agent logic here
+  const result = await processTask(type, payload);
+
+  await respond({
+    taskId: id,
+    result,
+    confidence: 0.95,
+    metadata: {
+      processingTime: Date.now(),
+      agentVersion: agent.version,
+    },
+  });
+});
+
+async function processTask(type, payload) {
+  // Add your agent logic here
+  switch (type) {
+    case 'research':
+      return { summary: 'Research result placeholder', sources: [] };
+    case 'social':
+      return { content: 'Generated content placeholder', platform: payload.platform };
+    default:
+      throw new Error(\`Unsupported task type: \${type}\`);
+  }
+}
+
+agent.start().then(() => {
+  console.log(\`Agent "${name}" is live and listening for tasks\`);
+});
+`;
+
+const PLURIBUS_CONFIG = (name, capabilities) => JSON.stringify({
+  name,
+  version: '0.1.0',
+  capabilities,
+  endpoint: 'https://your-agent-endpoint.com/webhook',
+  network: 'base-mainnet',
+  stake: {
+    tier: 'sentinel',
+    amount: 1000,
+  },
+  metadata: {
+    description: `${name} — Pluribus agent`,
+    framework: 'custom',
+    created: new Date().toISOString(),
+  },
+}, null, 2);
+
+const DOCKERFILE = (name) => `FROM node:20-alpine
+
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --production
+COPY . .
+
+EXPOSE 3000
+
+ENV NODE_ENV=production
+ENV AGENT_NAME="${name}"
+
+CMD ["node", "agent.js"]
+`;
+
+const PACKAGE_JSON = (name) => JSON.stringify({
+  name: name.toLowerCase().replace(/\s+/g, '-'),
+  version: '0.1.0',
+  type: 'module',
+  main: 'agent.js',
+  scripts: {
+    start: 'node agent.js',
+    dev: 'node --watch agent.js',
+    test: 'node --test',
+  },
+  dependencies: {
+    '@pluribus/agent-sdk': '^0.1.0',
+  },
+}, null, 2);
+
+const README = (name) => `# ${name}
+
+A Pluribus agent for the multi-agent coordination protocol on Base.
+
+## Setup
+
+\`\`\`bash
+npm install
+npm run dev
+\`\`\`
+
+## Deploy
+
+\`\`\`bash
+npx pluribus deploy
+\`\`\`
+
+## Configuration
+
+Edit \`pluribus.config.json\` to configure your agent's capabilities, stake tier, and endpoint.
+
+## Docs
+
+https://pluribus.xyz/docs/sdk
+`;
+
+export async function initAgent(name, options) {
+  const inquirer = (await import('inquirer')).default;
+
+  console.log('');
+  console.log(chalk.cyan.bold('  → Initialize New Agent Project'));
+  console.log(chalk.dim('    Scaffold a production-ready Pluribus agent'));
+  console.log('');
+
+  let agentName = name;
+  let capabilities;
+  let dir;
+
+  if (!agentName) {
+    const answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'name',
+        message: chalk.white('Agent name:'),
+        prefix: chalk.cyan(' ▸'),
+        validate: v => v.length >= 2 ? true : 'Name must be at least 2 characters',
+      },
+      {
+        type: 'checkbox',
+        name: 'capabilities',
+        message: chalk.white('Capabilities this agent will handle:'),
+        prefix: chalk.cyan(' ▸'),
+        choices: [
+          { name: 'research    — Market analysis, risk scoring', value: 'research', checked: true },
+          { name: 'social      — Content, posting, engagement', value: 'social' },
+          { name: 'onchain     — DeFi, swaps, bridge ops', value: 'onchain' },
+          { name: 'monitoring  — Wallets, TXs, alerts', value: 'monitoring' },
+          { name: 'data        — APIs, retrieval', value: 'data' },
+          { name: 'content     — Writing, summarization', value: 'content' },
+        ],
+        validate: v => v.length > 0 ? true : 'Select at least one capability',
+      },
+    ]);
+    agentName = answers.name;
+    capabilities = answers.capabilities;
+  } else {
+    capabilities = ['research'];
+  }
+
+  dir = agentName.toLowerCase().replace(/\s+/g, '-');
+
+  console.log('');
+  printDivider();
+  console.log('');
+
+  const spinner = ora({ text: chalk.dim(`Scaffolding agent project in ./${dir}/`), spinner: 'dots', color: 'cyan' }).start();
+
+  await sleep(400);
+
+  // Create directory
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  // Write files
+  fs.writeFileSync(path.join(dir, 'agent.js'), AGENT_TEMPLATE(agentName, capabilities));
+  fs.writeFileSync(path.join(dir, 'package.json'), PACKAGE_JSON(agentName));
+  fs.writeFileSync(path.join(dir, 'pluribus.config.json'), PLURIBUS_CONFIG(agentName, capabilities));
+  fs.writeFileSync(path.join(dir, 'Dockerfile'), DOCKERFILE(agentName));
+  fs.writeFileSync(path.join(dir, 'README.md'), README(agentName));
+  fs.writeFileSync(path.join(dir, '.gitignore'), 'node_modules/\n.env\n*.log\n');
+  fs.writeFileSync(path.join(dir, '.env.example'), 'PLURIBUS_API_KEY=\nAGENT_WEBHOOK_SECRET=\nRPC_URL=https://mainnet.base.org\n');
+
+  await sleep(600);
+  spinner.succeed(chalk.green(`Agent project created at ${chalk.cyan('./' + dir + '/')}`));
+
+  console.log('');
+  console.log(chalk.cyan.bold('  Files created:'));
+  printDivider();
+  const files = ['agent.js', 'package.json', 'pluribus.config.json', 'Dockerfile', 'README.md', '.gitignore', '.env.example'];
+  files.forEach(f => console.log(`  ${chalk.dim('+')} ${chalk.white(path.join(dir, f))}`));
+  console.log('');
+
+  console.log(chalk.cyan.bold('  Next steps:'));
+  printDivider();
+  console.log(`  ${chalk.dim('1.')} ${chalk.white(`cd ${dir}`)}`);
+  console.log(`  ${chalk.dim('2.')} ${chalk.white('npm install')}`);
+  console.log(`  ${chalk.dim('3.')} ${chalk.white('npm run dev')}   ${chalk.dim('# develop locally')}`);
+  console.log(`  ${chalk.dim('4.')} ${chalk.white('npx pluribus register')}   ${chalk.dim('# register when network launches')}`);
+  console.log(`  ${chalk.dim('5.')} ${chalk.white('npx pluribus deploy')}   ${chalk.dim('# deploy to Pluribus network')}`);
+  console.log('');
+  info(`Docs: ${chalk.underline('https://pluribus.xyz/sdk')}`);
+  console.log('');
+}

package/src/commands/list.js

@@ -0,0 +1,46 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { label, printDivider, info, warn } from '../utils/banner.js';
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+export async function listAgents(options) {
+  console.log('');
+  console.log(chalk.cyan.bold('  → Agent Registry'));
+  console.log(chalk.dim('    Browse agents registered on the Pluribus network'));
+  console.log('');
+
+  const spinner = ora({ text: chalk.dim('Querying agent registry...'), spinner: 'dots', color: 'cyan' }).start();
+  await sleep(1000);
+  spinner.succeed(chalk.green('Registry queried'));
+
+  console.log('');
+  printDivider();
+  console.log('');
+
+  console.log(`  ${chalk.cyan('No agents registered yet')} ${chalk.dim('— network is pre-launch')}`);
+  console.log('');
+
+  console.log(chalk.cyan.bold('  Staged Agents (local)'));
+  printDivider();
+  info('No local agents staged. Run ' + chalk.cyan('pluribus register') + ' to stage one.');
+  console.log('');
+
+  console.log(chalk.cyan.bold('  Supported Frameworks'));
+  printDivider();
+  const frameworks = [
+    { name: 'Virtuals Protocol', tag: 'virtuals' },
+    { name: 'ElizaOS', tag: 'eliza' },
+    { name: 'LangChain', tag: 'langchain' },
+    { name: 'AutoGPT', tag: 'autogpt' },
+    { name: 'CrewAI', tag: 'crewai' },
+    { name: 'Custom / Other', tag: 'custom' },
+  ];
+  frameworks.forEach(f => {
+    console.log(`  ${chalk.cyan('▸')} ${chalk.white(f.name.padEnd(22))} ${chalk.dim('[' + f.tag + ']')}`);
+  });
+  console.log('');
+
+  info(`Docs: ${chalk.underline('https://pluribus.xyz/agents')}`);
+  console.log('');
+}

package/src/commands/logs.js

@@ -0,0 +1,44 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { label, printDivider, info, warn } from '../utils/banner.js';
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+export async function logs(agentId, options) {
+  const inquirer = (await import('inquirer')).default;
+
+  console.log('');
+  console.log(chalk.cyan.bold('  → Agent Logs'));
+  console.log('');
+
+  if (!agentId) {
+    const answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'agentId',
+        message: chalk.white('Agent ID (PLR-XXXXXX or task ID):'),
+        prefix: chalk.cyan(' ▸'),
+        validate: v => v.length > 0 ? true : 'Agent ID is required',
+      },
+    ]);
+    agentId = answers.agentId;
+  }
+
+  const spinner = ora({ text: chalk.dim(`Connecting to agent ${chalk.cyan(agentId)}...`), spinner: 'dots', color: 'cyan' }).start();
+  await sleep(900);
+  spinner.succeed(chalk.green('Connected'));
+
+  console.log('');
+  printDivider();
+
+  console.log(`  ${chalk.dim('No logs available')} ${chalk.cyan('—')} ${chalk.dim('network is pre-launch')}`);
+  console.log('');
+
+  label('Agent:', agentId);
+  label('Status:', chalk.yellow('Awaiting network launch'));
+  label('Log stream:', chalk.yellow('Available post-launch'));
+  console.log('');
+
+  info('Once live, this command streams real-time task execution logs.');
+  console.log('');
+}

package/src/commands/register.js

@@ -0,0 +1,101 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { success, error, info, warn, label, printDivider } from '../utils/banner.js';
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+export async function registerAgent(options) {
+  const inquirer = (await import('inquirer')).default;
+
+  console.log('');
+  console.log(chalk.cyan.bold('  → Register New Agent'));
+  console.log(chalk.dim('    Create a new agent and stake $PLUR to join the network'));
+  console.log('');
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'name',
+      message: chalk.white('Agent name:'),
+      prefix: chalk.cyan(' ▸'),
+      validate: v => v.length >= 3 ? true : 'Name must be at least 3 characters',
+    },
+    {
+      type: 'input',
+      name: 'endpoint',
+      message: chalk.white('Agent webhook endpoint (https://...):'),
+      prefix: chalk.cyan(' ▸'),
+      validate: v => v.startsWith('http') ? true : 'Must be a valid URL',
+    },
+    {
+      type: 'list',
+      name: 'tier',
+      message: chalk.white('Staking tier:'),
+      prefix: chalk.cyan(' ▸'),
+      choices: [
+        { name: `Sentinel     ${chalk.dim('— Entry tier, basic yield')}`, value: 'sentinel' },
+        { name: `Archon       ${chalk.dim('— Mid tier, enhanced yield + priority routing')}`, value: 'archon' },
+        { name: `Sovereign    ${chalk.dim('— Elite tier, max yield + governance seat')}`, value: 'sovereign' },
+      ],
+    },
+    {
+      type: 'checkbox',
+      name: 'capabilities',
+      message: chalk.white('Capability tags:'),
+      prefix: chalk.cyan(' ▸'),
+      choices: [
+        { name: 'research     — Token analysis, risk scoring, market research', value: 'research' },
+        { name: 'social       — Twitter/X, Farcaster, content generation', value: 'social' },
+        { name: 'onchain      — DeFi execution, bridge ops, LP management', value: 'onchain' },
+        { name: 'monitoring   — Wallet watch, TX alerts, MEV detection', value: 'monitoring' },
+        { name: 'data         — APIs, retrieval, aggregation', value: 'data' },
+        { name: 'content      — Writing, summarization, translation', value: 'content' },
+      ],
+      validate: v => v.length > 0 ? true : 'Select at least one capability',
+    },
+    {
+      type: 'input',
+      name: 'wallet',
+      message: chalk.white('Wallet address (0x...):'),
+      prefix: chalk.cyan(' ▸'),
+      validate: v => v.startsWith('0x') && v.length === 42 ? true : 'Enter a valid Ethereum address',
+    },
+  ]);
+
+  const tierStake = { sentinel: '1,000', archon: '25,000', sovereign: '100,000' };
+
+  console.log('');
+  printDivider();
+  console.log('');
+
+  const spinner = ora({ text: chalk.dim('Generating agent identity...'), spinner: 'dots', color: 'cyan' }).start();
+  await sleep(900);
+  spinner.text = chalk.dim('Validating endpoint...');
+  await sleep(700);
+  spinner.text = chalk.dim('Computing capability fingerprint...');
+  await sleep(600);
+  spinner.text = chalk.dim('Staging on-chain registration...');
+  await sleep(800);
+  spinner.succeed(chalk.green('Agent staged for registration'));
+
+  const agentId = 'PLR-' + Math.random().toString(36).substring(2, 8).toUpperCase();
+
+  console.log('');
+  console.log(chalk.cyan.bold('  Registration Summary'));
+  printDivider();
+  label('Agent ID:', chalk.cyan(agentId));
+  label('Name:', answers.name);
+  label('Endpoint:', answers.endpoint);
+  label('Tier:', answers.tier.charAt(0).toUpperCase() + answers.tier.slice(1));
+  label('Stake Required:', `${tierStake[answers.tier]} $PLUR`);
+  label('Capabilities:', answers.capabilities.join(', '));
+  label('Wallet:', answers.wallet);
+  label('Network:', 'Base Mainnet');
+  label('Status:', chalk.yellow('Staged — pending launch'));
+  console.log('');
+
+  warn('Registration will finalize when the Pluribus network launches.');
+  info(`Your agent ID is ${chalk.cyan(agentId)} — save this for reference.`);
+  info(`Run ${chalk.cyan('pluribus status')} to check network launch status.`);
+  console.log('');
+}

package/src/commands/stake.js

@@ -0,0 +1,85 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { label, printDivider, warn, info, success } from '../utils/banner.js';
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+export async function stake(amount, options) {
+  const inquirer = (await import('inquirer')).default;
+
+  console.log('');
+  console.log(chalk.cyan.bold('  → Stake $PLUR'));
+  console.log(chalk.dim('    Stake tokens to earn yield from network task fees'));
+  console.log('');
+
+  if (!amount) {
+    const answers = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'tier',
+        message: chalk.white('Select staking tier:'),
+        prefix: chalk.cyan(' ▸'),
+        choices: [
+          { name: `Sentinel   ${chalk.dim('Entry tier  — basic yield')}`, value: 'sentinel' },
+          { name: `Archon     ${chalk.dim('Mid tier    — enhanced yield + routing')}`, value: 'archon' },
+          { name: `Sovereign  ${chalk.dim('Elite tier  — max yield + governance')}`, value: 'sovereign' },
+        ],
+      },
+      {
+        type: 'input',
+        name: 'amount',
+        message: chalk.white('Amount of $PLUR to stake:'),
+        prefix: chalk.cyan(' ▸'),
+        validate: v => !isNaN(Number(v)) && Number(v) > 0 ? true : 'Enter a valid amount',
+      },
+      {
+        type: 'input',
+        name: 'wallet',
+        message: chalk.white('Wallet address (0x...):'),
+        prefix: chalk.cyan(' ▸'),
+        validate: v => v.startsWith('0x') && v.length === 42 ? true : 'Enter a valid Ethereum address',
+      },
+    ]);
+    amount = answers.amount;
+
+    console.log('');
+    printDivider();
+    console.log('');
+
+    const spinner = ora({ text: chalk.dim('Preparing stake transaction...'), spinner: 'dots', color: 'cyan' }).start();
+    await sleep(700);
+    spinner.text = chalk.dim('Validating wallet...');
+    await sleep(600);
+    spinner.text = chalk.dim('Staging stake...');
+    await sleep(500);
+    spinner.succeed(chalk.green('Stake staged'));
+
+    console.log('');
+    label('Tier:', answers.tier.charAt(0).toUpperCase() + answers.tier.slice(1));
+    label('Amount:', `${Number(amount).toLocaleString()} $PLUR`);
+    label('Wallet:', answers.wallet);
+    label('APY:', chalk.cyan('TBA at launch'));
+    label('Status:', chalk.yellow('Staged — pending network launch'));
+    console.log('');
+    warn('Staking goes live when the Pluribus network launches on Base.');
+    info(`Run ${chalk.cyan('pluribus balance')} to check your $PLUR balance.`);
+    console.log('');
+  }
+}
+
+export async function unstake(amount, options) {
+  console.log('');
+  console.log(chalk.cyan.bold('  → Unstake $PLUR'));
+  console.log('');
+
+  const spinner = ora({ text: chalk.dim('Preparing unstake...'), spinner: 'dots', color: 'cyan' }).start();
+  await sleep(1000);
+  spinner.succeed(chalk.green('Unstake staged'));
+
+  console.log('');
+  label('Amount:', amount ? `${Number(amount).toLocaleString()} $PLUR` : 'All staked $PLUR');
+  label('Status:', chalk.yellow('Staged — pending network launch'));
+  console.log('');
+  warn('Unstake will execute when the Pluribus staking contract is live.');
+  console.log('');
+}

package/src/commands/status.js

@@ -0,0 +1,45 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { label, printDivider, info } from '../utils/banner.js';
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+export async function networkStatus() {
+  console.log('');
+  console.log(chalk.cyan.bold('  → Network Status'));
+  console.log('');
+
+  const spinner = ora({ text: chalk.dim('Querying Pluribus network...'), spinner: 'dots', color: 'cyan' }).start();
+  await sleep(1100);
+  spinner.succeed(chalk.green('Status retrieved'));
+
+  console.log('');
+  console.log(chalk.cyan.bold('  Protocol Status'));
+  printDivider();
+  label('Network:', 'Base Mainnet');
+  label('Launch Phase:', chalk.yellow('Pre-Launch'));
+  label('Protocol Status:', chalk.yellow('● Staging'));
+  label('Contracts:', chalk.yellow('Deploying soon'));
+  label('Agent Registry:', chalk.yellow('Opening soon'));
+  label('Task Queue:', chalk.yellow('Coming soon'));
+  console.log('');
+
+  console.log(chalk.cyan.bold('  Network Metrics'));
+  printDivider();
+  label('Agents Staged:', chalk.cyan('—'));
+  label('Tasks Processed:', chalk.cyan('—'));
+  label('$PLUR Burned:', chalk.cyan('—'));
+  label('Staker APY:', chalk.cyan('TBA at launch'));
+  label('Uptime:', chalk.cyan('—'));
+  console.log('');
+
+  console.log(chalk.cyan.bold('  CLI Version'));
+  printDivider();
+  label('CLI:', '0.1.0');
+  label('SDK Target:', '0.1.0');
+  label('Node.js:', process.version);
+  console.log('');
+
+  info(`Follow ${chalk.underline('https://pluribus.xyz')} for launch updates.`);
+  console.log('');
+}

package/src/commands/submit.js

@@ -0,0 +1,84 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { label, printDivider, warn, info } from '../utils/banner.js';
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+export async function submitTask(taskDescription, options) {
+  const inquirer = (await import('inquirer')).default;
+
+  console.log('');
+  console.log(chalk.cyan.bold('  → Submit Task'));
+  console.log(chalk.dim('    Submit a task to the Pluribus agent network'));
+  console.log('');
+
+  let task = taskDescription;
+  let taskType, plur;
+
+  if (!task) {
+    const answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'task',
+        message: chalk.white('Describe your task:'),
+        prefix: chalk.cyan(' ▸'),
+        validate: v => v.length >= 10 ? true : 'Please provide a meaningful task description',
+      },
+      {
+        type: 'list',
+        name: 'type',
+        message: chalk.white('Task type:'),
+        prefix: chalk.cyan(' ▸'),
+        choices: [
+          { name: 'research    — Analysis, research, risk scoring', value: 'research' },
+          { name: 'social      — Post, thread, engagement', value: 'social' },
+          { name: 'monitoring  — Watch wallet or contract', value: 'monitoring' },
+          { name: 'onchain     — Execute onchain action', value: 'onchain' },
+          { name: 'auto        — Let the orchestrator decide', value: 'auto' },
+        ],
+      },
+      {
+        type: 'input',
+        name: 'plur',
+        message: chalk.white('$PLUR to pay (determines priority):'),
+        prefix: chalk.cyan(' ▸'),
+        default: '0.5',
+        validate: v => !isNaN(Number(v)) && Number(v) > 0 ? true : 'Enter a valid amount',
+      },
+    ]);
+    task = answers.task;
+    taskType = answers.type;
+    plur = answers.plur;
+  } else {
+    taskType = options.type || 'auto';
+    plur = options.plur || '0.5';
+  }
+
+  console.log('');
+  printDivider();
+  console.log('');
+
+  const spinner = ora({ text: chalk.dim('Connecting to orchestrator...'), spinner: 'dots', color: 'cyan' }).start();
+  await sleep(800);
+  spinner.text = chalk.dim('Routing to best agents...');
+  await sleep(600);
+  spinner.text = chalk.dim('Staging task submission...');
+  await sleep(700);
+  spinner.succeed(chalk.green('Task staged'));
+
+  const taskId = '#' + Math.floor(Math.random() * 90000 + 10000);
+
+  console.log('');
+  console.log(chalk.cyan.bold('  Task Summary'));
+  printDivider();
+  label('Task ID:', chalk.cyan(taskId));
+  label('Description:', task.length > 50 ? task.slice(0, 50) + '...' : task);
+  label('Type:', taskType);
+  label('$PLUR:', plur);
+  label('Status:', chalk.yellow('Staged — pending network launch'));
+  console.log('');
+
+  warn('Task submission goes live when the Pluribus network launches.');
+  info(`Task ID ${chalk.cyan(taskId)} saved. Run ${chalk.cyan('pluribus logs ' + taskId)} post-launch to track results.`);
+  console.log('');
+}

package/src/utils/banner.js

@@ -0,0 +1,45 @@
+import chalk from 'chalk';
+
+export function printBanner() {
+  const cyan = chalk.cyan;
+  const dim = chalk.dim;
+  const bold = chalk.bold;
+
+  console.log('');
+  console.log(cyan.bold('  ██████╗ ██╗     ██╗   ██╗██████╗ ██╗██████╗ ██╗   ██╗███████╗'));
+  console.log(cyan.bold('  ██╔══██╗██║     ██║   ██║██╔══██╗██║██╔══██╗██║   ██║██╔════╝'));
+  console.log(cyan.bold('  ██████╔╝██║     ██║   ██║██████╔╝██║██████╔╝██║   ██║███████╗'));
+  console.log(cyan.bold('  ██╔═══╝ ██║     ██║   ██║██╔══██╗██║██╔══██╗██║   ██║╚════██║'));
+  console.log(cyan.bold('  ██║     ███████╗╚██████╔╝██║  ██║██║██████╔╝╚██████╔╝███████║'));
+  console.log(cyan.bold('  ╚═╝     ╚══════╝ ╚═════╝ ╚═╝  ╚═╝╚═╝╚═════╝  ╚═════╝ ╚══════╝'));
+  console.log('');
+  console.log(`  ${chalk.magenta('E PLURIBUS UNUM')}  ${dim('—')}  ${chalk.white.bold('Many Agents. One Mind.')}`);
+  console.log(`  ${dim('Multi-Agent Coordination Protocol on Base')}`);
+  console.log('');
+  console.log(`  ${dim('Version')} ${chalk.cyan('0.1.0')}  ${dim('·')}  ${chalk.underline.dim('https://pluribus.xyz')}`);
+  console.log('');
+}
+
+export function printDivider() {
+  console.log(chalk.dim('  ' + '─'.repeat(60)));
+}
+
+export function success(msg) {
+  console.log(`  ${chalk.green('✓')} ${chalk.white(msg)}`);
+}
+
+export function error(msg) {
+  console.log(`  ${chalk.red('✗')} ${chalk.white(msg)}`);
+}
+
+export function info(msg) {
+  console.log(`  ${chalk.cyan('ℹ')} ${chalk.white(msg)}`);
+}
+
+export function warn(msg) {
+  console.log(`  ${chalk.yellow('⚠')} ${chalk.white(msg)}`);
+}
+
+export function label(key, val) {
+  console.log(`  ${chalk.dim(key.padEnd(20))} ${chalk.white(val)}`);
+}