@paylobster/cli 4.3.1 → 4.5.0

package/src/commands/quickstart.ts

@@ -0,0 +1,150 @@
+import { Command } from 'commander';
+import { getAgentInfo, registerAgent } from '../lib/contracts';
+import { getWalletAddress } from '../lib/wallet';
+import { error, success } from '../lib/display';
+import chalk from 'chalk';
+import ora from 'ora';
+import readline from 'readline';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+function prompt(question: string): Promise<string> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+export function createQuickstartCommand(): Command {
+  const cmd = new Command('quickstart')
+    .description('🚀 Interactive wizard to get started with PayLobster')
+    .action(async () => {
+      console.log(chalk.cyan.bold('\n🦞 PayLobster Quickstart Wizard\n'));
+      console.log(chalk.gray('Let\'s get you set up with PayLobster in just a few steps.\n'));
+
+      try {
+        // Step 1: Check wallet configuration
+        console.log(chalk.cyan('Step 1/5:'), chalk.bold('Wallet Configuration'));
+        
+        let address: `0x${string}`;
+        try {
+          address = getWalletAddress() as `0x${string}`;
+        } catch (err) {
+          console.log(chalk.yellow('⚠️  No wallet configured yet.'));
+          console.log('Please run:', chalk.green('plob auth setup'));
+          console.log('Then come back and run', chalk.green('plob quickstart'), 'again.\n');
+          return;
+        }
+        console.log(chalk.green('✓'), 'Wallet configured:', chalk.gray(address));
+
+        // Check if already registered
+        const spinner = ora('Checking registration status...').start();
+        const agentInfo = await getAgentInfo(address);
+        spinner.stop();
+
+        if (agentInfo.registered) {
+          console.log(chalk.green('✓'), 'Already registered as:', chalk.bold(agentInfo.name));
+          console.log(chalk.yellow('\nYou\'re all set! Run'), chalk.green('plob whoami'), chalk.yellow('to see your profile.\n'));
+          return;
+        }
+
+        console.log(chalk.gray('Not registered yet. Let\'s continue...\n'));
+
+        // Step 2: Register agent identity
+        console.log(chalk.cyan('Step 2/5:'), chalk.bold('Agent Identity'));
+        
+        const name = await prompt(chalk.white('Agent name: '));
+        if (!name) {
+          console.log(chalk.red('Name is required. Exiting.\n'));
+          return;
+        }
+
+        const capabilities = await prompt(chalk.white('Capabilities (comma-separated, e.g., "code review, testing, docs"): '));
+        if (!capabilities) {
+          console.log(chalk.red('Capabilities are required. Exiting.\n'));
+          return;
+        }
+
+        spinner.start('Registering agent identity...');
+        try {
+          const tokenId = await registerAgent(name, capabilities);
+          spinner.succeed(chalk.green('✓ Agent registered! Token ID: ') + chalk.bold(tokenId.toString()));
+        } catch (err: any) {
+          spinner.fail(chalk.red('Failed to register agent'));
+          error(`Registration error: ${err.message}`);
+          return;
+        }
+
+        // Step 3: Create treasury
+        console.log(chalk.cyan('\nStep 3/5:'), chalk.bold('Treasury Setup'));
+        console.log(chalk.gray('A treasury manages your funds with budgets and spending rules.'));
+        
+        const createTreasury = await prompt(chalk.white('Create a treasury? (y/n): '));
+        
+        if (createTreasury.toLowerCase() === 'y') {
+          const treasuryName = await prompt(chalk.white('Treasury name: ')) || `${name} Treasury`;
+          
+          spinner.start('Creating treasury...');
+          try {
+            await execAsync(`plob treasury create --name "${treasuryName}"`);
+            spinner.succeed(chalk.green('✓ Treasury created: ') + chalk.bold(treasuryName));
+          } catch (err: any) {
+            spinner.fail(chalk.red('Failed to create treasury'));
+            console.log(chalk.yellow('You can create one later with:'), chalk.green('plob treasury create'));
+          }
+
+          // Step 4: Set default budget
+          console.log(chalk.cyan('\nStep 4/5:'), chalk.bold('Budget Allocation'));
+          console.log(chalk.gray('Recommended: 40% operations, 30% growth, 20% reserve, 10% rewards'));
+          
+          const setBudget = await prompt(chalk.white('Use default budget allocation? (y/n): '));
+          
+          if (setBudget.toLowerCase() === 'y') {
+            spinner.start('Setting budget...');
+            try {
+              await execAsync('plob treasury budget --operations 40 --growth 30 --reserve 20 --rewards 10');
+              spinner.succeed(chalk.green('✓ Budget configured'));
+            } catch (err: any) {
+              spinner.fail(chalk.red('Failed to set budget'));
+              console.log(chalk.yellow('You can set it later with:'), chalk.green('plob treasury budget'));
+            }
+          }
+        } else {
+          console.log(chalk.gray('Skipped treasury setup.'));
+        }
+
+        // Step 5: Summary
+        console.log(chalk.cyan('\nStep 5/5:'), chalk.bold('Summary'));
+        console.log(chalk.green.bold('\n🎉 You\'re all set!\n'));
+        
+        console.log(chalk.bold('What you created:'));
+        console.log(chalk.green('  ✓'), 'Agent identity:', chalk.bold(name));
+        console.log(chalk.green('  ✓'), 'Capabilities:', chalk.gray(capabilities));
+        if (createTreasury.toLowerCase() === 'y') {
+          console.log(chalk.green('  ✓'), 'Treasury with budget allocation');
+        }
+
+        console.log(chalk.bold('\nNext steps:'));
+        console.log(chalk.cyan('  •'), 'View your profile:', chalk.green('plob whoami'));
+        console.log(chalk.cyan('  •'), 'Check system health:', chalk.green('plob health'));
+        console.log(chalk.cyan('  •'), 'Open dashboard:', chalk.green('plob dashboard'));
+        console.log(chalk.cyan('  •'), 'Make your first payment:', chalk.green('plob pay <address> <amount>'));
+        console.log();
+
+      } catch (err: any) {
+        error(`Quickstart failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

package/src/commands/search.ts

@@ -0,0 +1,151 @@
+import { Command } from 'commander';
+import { getPublicClient, getContracts, getAgentInfo, getReputation } from '../lib/contracts';
+import { loadConfig } from '../lib/config';
+import { error, outputJSON } from '../lib/display';
+import type { OutputOptions } from '../lib/types';
+import chalk from 'chalk';
+import ora from 'ora';
+import type { Address } from 'viem';
+
+interface AgentSearchResult {
+  address: Address;
+  name: string;
+  capabilities: string;
+  reputationScore: number;
+  tokenId: string;
+}
+
+// ABI for AgentRegistered event
+const AGENT_REGISTERED_EVENT = {
+  anonymous: false,
+  inputs: [
+    { indexed: true, name: 'agent', type: 'address' },
+    { indexed: true, name: 'tokenId', type: 'uint256' },
+    { indexed: false, name: 'name', type: 'string' },
+    { indexed: false, name: 'capabilities', type: 'string' },
+  ],
+  name: 'AgentRegistered',
+  type: 'event',
+} as const;
+
+export function createSearchCommand(): Command {
+  const cmd = new Command('search')
+    .description('🔍 Search for agents by name or capability')
+    .argument('<query>', 'Search query (name or capability)')
+    .option('--json', 'Output as JSON')
+    .option('--limit <number>', 'Maximum number of results', '10')
+    .action(async (query: string, options: OutputOptions & { limit?: string }) => {
+      const spinner = ora('Searching for agents...').start();
+
+      try {
+        const config = loadConfig();
+        const client = getPublicClient(config.network);
+        const contracts = getContracts(config.network);
+        const limit = parseInt(options.limit || '10');
+
+        // Get AgentRegistered events
+        // Note: This will scan the entire chain history which may be slow
+        // In production, you'd want to use a subgraph or indexer
+        const logs = await client.getLogs({
+          address: contracts.IDENTITY,
+          event: AGENT_REGISTERED_EVENT,
+          fromBlock: 'earliest',
+          toBlock: 'latest',
+        });
+
+        spinner.text = 'Processing results...';
+
+        // Filter by query (case-insensitive)
+        const queryLower = query.toLowerCase();
+        const matchingLogs = logs.filter((log) => {
+          const name = (log.args.name || '').toLowerCase();
+          const capabilities = (log.args.capabilities || '').toLowerCase();
+          return name.includes(queryLower) || capabilities.includes(queryLower);
+        });
+
+        // Limit results
+        const limitedLogs = matchingLogs.slice(0, limit);
+
+        // Fetch reputation for each agent
+        const results: AgentSearchResult[] = await Promise.all(
+          limitedLogs.map(async (log) => {
+            const address = log.args.agent!;
+            const reputation = await getReputation(address);
+            
+            return {
+              address,
+              name: log.args.name || 'Unknown',
+              capabilities: log.args.capabilities || 'None',
+              reputationScore: Number(reputation.score),
+              tokenId: log.args.tokenId?.toString() || '0',
+            };
+          })
+        );
+
+        spinner.stop();
+
+        // JSON output
+        if (outputJSON({
+          query,
+          results,
+          total: matchingLogs.length,
+          showing: results.length,
+        }, options)) {
+          return;
+        }
+
+        // Pretty output
+        console.log('\n' + chalk.cyan.bold('═══════════════════════════════════════════════════════════'));
+        console.log(chalk.cyan.bold('                   🔍 Agent Search'));
+        console.log(chalk.cyan.bold('═══════════════════════════════════════════════════════════\n'));
+
+        console.log(chalk.gray('  Query:     '), chalk.white(query));
+        console.log(chalk.gray('  Results:   '), chalk.white(`${results.length} / ${matchingLogs.length}`));
+        console.log();
+
+        if (results.length === 0) {
+          console.log(chalk.yellow('  No agents found matching your query.'));
+          console.log();
+          return;
+        }
+
+        // Display results
+        for (let i = 0; i < results.length; i++) {
+          const agent = results[i];
+          
+          let reputationColor = chalk.red;
+          if (agent.reputationScore >= 80) reputationColor = chalk.green;
+          else if (agent.reputationScore >= 50) reputationColor = chalk.yellow;
+
+          console.log(chalk.bold(`  ${i + 1}. ${agent.name}`), chalk.gray(`(#${agent.tokenId})`));
+          console.log(chalk.gray('     Address:      '), chalk.dim(agent.address));
+          console.log(chalk.gray('     Reputation:   '), reputationColor(agent.reputationScore.toString()));
+          console.log(chalk.gray('     Capabilities: '), chalk.white(agent.capabilities));
+          console.log();
+        }
+
+        if (matchingLogs.length > results.length) {
+          console.log(chalk.gray(`  ... and ${matchingLogs.length - results.length} more results`));
+          console.log(chalk.gray('  Use --limit to see more'));
+          console.log();
+        }
+
+        console.log(chalk.cyan.bold('═══════════════════════════════════════════════════════════\n'));
+
+      } catch (err: any) {
+        spinner.stop();
+        error(`Search failed: ${err.message}`);
+        
+        // Provide helpful error message for common issues
+        if (err.message.includes('block range')) {
+          console.log(chalk.yellow('\n⚠️  The search requires scanning many blocks.'));
+          console.log(chalk.gray('This may be slow or hit rate limits with public RPCs.'));
+          console.log(chalk.gray('Consider using a dedicated RPC endpoint or subgraph.\n'));
+        }
+        
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

package/src/commands/trust-graph.ts

@@ -0,0 +1,267 @@
+import { Command } from 'commander';
+import { getTrustGraph } from '../lib/contracts';
+import { error, success, outputJSON, header, info } from '../lib/display';
+import type { OutputOptions } from '../lib/types';
+import type { Address } from 'viem';
+
+export function createTrustGraphCommand(): Command {
+  const cmd = new Command('trust')
+    .description('Manage and query trust network')
+    .addHelpText('after', `
+Examples:
+  $ plob trust endorse 0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb 85
+  $ plob trust revoke 0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb
+  $ plob trust check 0xAlice 0xBob
+  $ plob trust score 0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb
+  $ plob trust endorsements 0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb
+    `);
+
+  // Endorse agent
+  cmd
+    .command('endorse')
+    .description('Endorse another agent with a trust level')
+    .argument('<address>', 'Agent address to endorse')
+    .argument('<score>', 'Trust score (1-100)')
+    .option('--json', 'Output as JSON')
+    .action(async (addressArg: string, scoreArg: string, options: OutputOptions) => {
+      try {
+        const address = addressArg as Address;
+        const score = parseInt(scoreArg);
+
+        if (score < 1 || score > 100) {
+          error('Trust score must be between 1 and 100');
+          process.exit(1);
+        }
+
+        const trustGraph = getTrustGraph();
+        
+        info(`Endorsing ${address} with trust level ${score}...`);
+        const hash = await trustGraph.endorseAgent(address, score);
+
+        if (outputJSON({ transactionHash: hash, endorsed: address, trustLevel: score }, options)) {
+          return;
+        }
+
+        success(`Endorsed ${address} with trust level ${score}/100`);
+        console.log(`Transaction: ${hash}`);
+      } catch (err) {
+        error(`Failed to endorse agent: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // Revoke endorsement
+  cmd
+    .command('revoke')
+    .description('Revoke an endorsement')
+    .argument('<address>', 'Agent address to revoke endorsement from')
+    .option('--json', 'Output as JSON')
+    .action(async (addressArg: string, options: OutputOptions) => {
+      try {
+        const address = addressArg as Address;
+        const trustGraph = getTrustGraph();
+        
+        info(`Revoking endorsement of ${address}...`);
+        const hash = await trustGraph.revokeEndorsement(address);
+
+        if (outputJSON({ transactionHash: hash, revoked: address }, options)) {
+          return;
+        }
+
+        success(`Revoked endorsement of ${address}`);
+        console.log(`Transaction: ${hash}`);
+      } catch (err) {
+        error(`Failed to revoke endorsement: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // Check trust between two agents
+  cmd
+    .command('check')
+    .description('Check trust level between two agents')
+    .argument('<from>', 'Source agent address')
+    .argument('<to>', 'Target agent address')
+    .option('--inferred', 'Calculate inferred trust through network')
+    .option('--depth <number>', 'Max hops for inferred trust (default: 4)', '4')
+    .option('--json', 'Output as JSON')
+    .action(async (fromArg: string, toArg: string, options: any) => {
+      try {
+        const from = fromArg as Address;
+        const to = toArg as Address;
+        const trustGraph = getTrustGraph();
+
+        if (options.inferred) {
+          // Get inferred trust through network
+          const maxDepth = parseInt(options.depth);
+          const result = await trustGraph.getInferredTrust(from, to, maxDepth);
+
+          if (outputJSON({ from, to, trustScore: result.trustScore, pathLength: result.pathLength, type: 'inferred' }, options)) {
+            return;
+          }
+
+          header('Inferred Trust');
+          console.log();
+          console.log('From:        ', from);
+          console.log('To:          ', to);
+          console.log('Trust Score: ', result.trustScore);
+          console.log('Path Length: ', result.pathLength, 'hops');
+          console.log();
+        } else {
+          // Get direct trust
+          const trustLevel = await trustGraph.getDirectTrust(from, to);
+
+          if (outputJSON({ from, to, trustLevel, type: 'direct' }, options)) {
+            return;
+          }
+
+          header('Direct Trust');
+          console.log();
+          console.log('From:        ', from);
+          console.log('To:          ', to);
+          console.log('Trust Level: ', trustLevel === 0 ? 'No direct endorsement' : `${trustLevel}/100`);
+          console.log();
+        }
+      } catch (err) {
+        error(`Failed to check trust: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // Get aggregate trust score
+  cmd
+    .command('score')
+    .description('Get aggregate trust score for an agent')
+    .argument('<address>', 'Agent address')
+    .option('--json', 'Output as JSON')
+    .action(async (addressArg: string, options: OutputOptions) => {
+      try {
+        const address = addressArg as Address;
+        const trustGraph = getTrustGraph();
+
+        const [aggregateScore, endorsers] = await Promise.all([
+          trustGraph.getAggregateTrust(address),
+          trustGraph.getEndorsers(address),
+        ]);
+
+        if (outputJSON({ address, aggregateScore, endorserCount: endorsers.length }, options)) {
+          return;
+        }
+
+        header('Trust Score');
+        console.log();
+        console.log('Agent:            ', address);
+        console.log('Aggregate Score:  ', aggregateScore);
+        console.log('Endorser Count:   ', endorsers.length);
+        console.log();
+
+        if (aggregateScore >= 80) {
+          console.log('✅ Highly trusted in the network');
+        } else if (aggregateScore >= 60) {
+          console.log('✅ Well trusted in the network');
+        } else if (aggregateScore >= 40) {
+          console.log('⚠️  Moderately trusted');
+        } else if (aggregateScore > 0) {
+          console.log('⚠️  Limited trust in the network');
+        } else {
+          console.log('❌ No endorsements yet');
+        }
+        console.log();
+      } catch (err) {
+        error(`Failed to get trust score: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // Get endorsements (agents this address has endorsed)
+  cmd
+    .command('endorsements')
+    .description('List all agents endorsed by an address')
+    .argument('[address]', 'Agent address (default: your wallet)')
+    .option('--json', 'Output as JSON')
+    .action(async (addressArg: string | undefined, options: OutputOptions) => {
+      try {
+        let address: Address;
+
+        if (addressArg) {
+          address = addressArg as Address;
+        } else {
+          const { getWalletAddress } = await import('../lib/wallet');
+          address = getWalletAddress() as Address;
+        }
+
+        const trustGraph = getTrustGraph();
+        const endorsed = await trustGraph.getEndorsements(address);
+
+        if (outputJSON({ address, endorsed, count: endorsed.length }, options)) {
+          return;
+        }
+
+        header('Endorsements');
+        console.log();
+        console.log('Endorser:    ', address);
+        console.log('Endorsed:    ', endorsed.length, 'agents');
+        console.log();
+
+        if (endorsed.length > 0) {
+          endorsed.forEach((agent, i) => {
+            console.log(`  ${i + 1}. ${agent}`);
+          });
+          console.log();
+        } else {
+          console.log('No endorsements yet.');
+          console.log();
+        }
+      } catch (err) {
+        error(`Failed to get endorsements: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // Get endorsers (agents who endorse this address)
+  cmd
+    .command('endorsers')
+    .description('List all agents who endorse an address')
+    .argument('[address]', 'Agent address (default: your wallet)')
+    .option('--json', 'Output as JSON')
+    .action(async (addressArg: string | undefined, options: OutputOptions) => {
+      try {
+        let address: Address;
+
+        if (addressArg) {
+          address = addressArg as Address;
+        } else {
+          const { getWalletAddress } = await import('../lib/wallet');
+          address = getWalletAddress() as Address;
+        }
+
+        const trustGraph = getTrustGraph();
+        const endorsers = await trustGraph.getEndorsers(address);
+
+        if (outputJSON({ address, endorsers, count: endorsers.length }, options)) {
+          return;
+        }
+
+        header('Endorsers');
+        console.log();
+        console.log('Endorsed:    ', address);
+        console.log('Endorsers:   ', endorsers.length, 'agents');
+        console.log();
+
+        if (endorsers.length > 0) {
+          endorsers.forEach((agent, i) => {
+            console.log(`  ${i + 1}. ${agent}`);
+          });
+          console.log();
+        } else {
+          console.log('No endorsers yet.');
+          console.log();
+        }
+      } catch (err) {
+        error(`Failed to get endorsers: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}