Examples - Agent Hustle

// PortfolioTracker.tsx
import React, { useState } from 'react';
import { HustleIncognitoClient } from 'hustle-incognito';

const client = new HustleIncognitoClient({
  apiKey: process.env.REACT_APP_HUSTLE_API_KEY
});

export function PortfolioTracker() {
  const [walletAddress, setWalletAddress] = useState('');
  const [analysis, setAnalysis] = useState('');
  const [loading, setLoading] = useState(false);

  const analyzePortfolio = async () => {
    if (!walletAddress) return;

    setLoading(true);
    setAnalysis('');

    try {
      for await (const chunk of client.chatStream({
        messages: [{
          role: 'user',
          content: `Analyze the portfolio for wallet address ${walletAddress}. Provide insights on allocation, performance, and recommendations.`
        }],
        vaultId: process.env.REACT_APP_VAULT_ID,
        selectedToolCategories: ['standard-tools', 'blockchain-analysis'],
        processChunks: true
      })) {
        if (chunk.type === 'text') {
          setAnalysis(prev => prev + chunk.value);
        }
      }
    } catch (error) {
      setAnalysis(`Error: ${error.message}`);
    } finally {
      setLoading(false);
    }
  };

  return (
    <div style={{ padding: '20px', maxWidth: '800px', margin: '0 auto' }}>
      <h1>Portfolio Analysis</h1>

      <div style={{ marginBottom: '20px' }}>
        <input
          type="text"
          value={walletAddress}
          onChange={(e) => setWalletAddress(e.target.value)}
          placeholder="Enter wallet address"
          style={{ width: '70%', padding: '10px', marginRight: '10px' }}
        />
        <button
          onClick={analyzePortfolio}
          disabled={loading || !walletAddress}
          style={{ padding: '10px 20px' }}
        >
          {loading ? 'Analyzing...' : 'Analyze'}
        </button>
      </div>

      {analysis && (
        <div style={{
          background: '#f5f5f5',
          padding: '20px',
          borderRadius: '8px',
          whiteSpace: 'pre-wrap'
        }}>
          {analysis}
        </div>
      )}
    </div>
  );
}

// trading-bot.js
import { HustleIncognitoClient } from 'hustle-incognito';

class TradingBot {
  constructor() {
    this.client = new HustleIncognitoClient({
      apiKey: process.env.HUSTLE_API_KEY,
      debug: true
    });

    this.watchedTokens = ['BTC', 'ETH', 'SOL', 'BONK'];
    this.isRunning = false;
  }

  async start() {
    console.log('🤖 Trading Bot starting...');
    this.isRunning = true;

    while (this.isRunning) {
      try {
        await this.analyzeMarkets();
        await this.sleep(300000); // 5 minutes
      } catch (error) {
        console.error('Bot error:', error);
        await this.sleep(60000); // 1 minute retry
      }
    }
  }

  async analyzeMarkets() {
    console.log('📊 Analyzing markets...');

    for (const token of this.watchedTokens) {
      const analysis = await this.client.chat([{
        role: 'user',
        content: `Analyze ${token} for trading opportunities. Consider price action, volume, and market sentiment. Provide specific entry/exit recommendations.`
      }], {
        vaultId: process.env.VAULT_ID,
        selectedToolCategories: ['standard-tools', 'trading', 'market-analysis']
      });

      console.log(`\n📈 ${token} Analysis:`);
      console.log(analysis.content);

      // Check for trading signals
      if (analysis.content.toLowerCase().includes('buy signal') ||
          analysis.content.toLowerCase().includes('strong buy')) {
        await this.handleBuySignal(token, analysis.content);
      }
    }
  }

  async handleBuySignal(token, analysis) {
    console.log(`🚨 Buy signal detected for ${token}!`);

    // Risk assessment
    const riskAnalysis = await this.client.chat([{
      role: 'user',
      content: `Assess the risk for buying ${token} right now. What position size would you recommend?`
    }], {
      vaultId: process.env.VAULT_ID,
      selectedToolCategories: ['risk-management', 'portfolio-analysis']
    });

    console.log('⚖️  Risk Assessment:');
    console.log(riskAnalysis.content);

    // In a real bot, you would execute the trade here
    console.log(`📝 Would execute buy order for ${token}`);

    // Log to file or database
    this.logTrade({
      timestamp: new Date().toISOString(),
      action: 'BUY_SIGNAL',
      token,
      analysis: analysis.substring(0, 200) + '...',
      riskAssessment: riskAnalysis.content.substring(0, 200) + '...'
    });
  }

  logTrade(tradeLog) {
    console.log('📋 Trade Log:', JSON.stringify(tradeLog, null, 2));
    // In production, save to database or file
  }

  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }

  stop() {
    console.log('🛑 Stopping trading bot...');
    this.isRunning = false;
  }
}

// Start the bot
const bot = new TradingBot();

// Graceful shutdown
process.on('SIGINT', () => {
  bot.stop();
  process.exit(0);
});

bot.start().catch(console.error);

// app/api/agent/route.ts
import { HustleIncognitoClient } from 'hustle-incognito';

const client = new HustleIncognitoClient({
  apiKey: process.env.HUSTLE_API_KEY!
});

export async function POST(request: Request) {
  try {
    const { message, vaultId } = await request.json();

    const response = await client.chat([
      { role: 'user', content: message }
    ], {
      vaultId: vaultId || process.env.VAULT_ID!,
      selectedToolCategories: ['standard-tools']
    });

    return Response.json({
      content: response.content,
      usage: response.usage,
      toolCalls: response.toolCalls
    });
  } catch (error) {
    return Response.json(
      { error: 'Failed to process request' },
      { status: 500 }
    );
  }
}

// app/components/AgentChat.tsx
'use client';

import { useState } from 'react';

export default function AgentChat() {
  const [message, setMessage] = useState('');
  const [response, setResponse] = useState('');
  const [loading, setLoading] = useState(false);

  const sendMessage = async () => {
    if (!message.trim()) return;

    setLoading(true);
    try {
      const res = await fetch('/api/agent', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ message })
      });

      const data = await res.json();
      setResponse(data.content || data.error);
    } catch (error) {
      setResponse('Error: Failed to send message');
    } finally {
      setLoading(false);
    }
  };

  return (
    <div className="max-w-2xl mx-auto p-6">
      <h1 className="text-2xl font-bold mb-6">Agent Hustle Chat</h1>

      <div className="mb-4">
        <textarea
          value={message}
          onChange={(e) => setMessage(e.target.value)}
          placeholder="Ask about crypto prices, market analysis..."
          className="w-full p-3 border rounded-lg"
          rows={3}
        />
        <button
          onClick={sendMessage}
          disabled={loading}
          className="mt-2 px-4 py-2 bg-blue-500 text-white rounded disabled:opacity-50"
        >
          {loading ? 'Sending...' : 'Send'}
        </button>
      </div>

      {response && (
        <div className="p-4 bg-gray-100 rounded-lg">
          <h3 className="font-semibold mb-2">Agent Response:</h3>
          <p className="whitespace-pre-wrap">{response}</p>
        </div>
      )}
    </div>
  );
}