bzzz/examples/sdk/go/simple-client.go

package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"github.com/anthonyrawlins/bzzz/sdk/bzzz"
	"github.com/anthonyrawlins/bzzz/sdk/decisions"
)

// Simple BZZZ SDK client example
// Shows basic connection, status checks, and decision publishing
func main() {
	fmt.Println("🚀 BZZZ SDK Simple Client Example")

	// Create context with timeout
	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
	defer cancel()

	// Initialize BZZZ client
	client, err := bzzz.NewClient(bzzz.Config{
		Endpoint: "http://localhost:8080",
		Role:     "backend_developer",
		Timeout:  30 * time.Second,
	})
	if err != nil {
		log.Fatalf("Failed to create BZZZ client: %v", err)
	}
	defer client.Close()

	// Get and display agent status
	status, err := client.GetStatus(ctx)
	if err != nil {
		log.Fatalf("Failed to get status: %v", err)
	}

	fmt.Printf("✅ Connected to BZZZ node\n")
	fmt.Printf("   Node ID: %s\n", status.NodeID)
	fmt.Printf("   Agent ID: %s\n", status.AgentID)
	fmt.Printf("   Role: %s\n", status.Role)
	fmt.Printf("   Authority Level: %s\n", status.AuthorityLevel)
	fmt.Printf("   Can decrypt: %v\n", status.CanDecrypt)
	fmt.Printf("   Active tasks: %d/%d\n", status.ActiveTasks, status.MaxTasks)

	// Create decisions client
	decisionsClient := decisions.NewClient(client)

	// Publish a simple code decision
	fmt.Println("\n📝 Publishing code decision...")
	err = decisionsClient.PublishCode(ctx, decisions.CodeDecision{
		Task:         "implement_simple_client",
		Decision:     "Created a simple BZZZ SDK client example",
		FilesModified: []string{"examples/sdk/go/simple-client.go"},
		LinesChanged: 75,
		TestResults: &decisions.TestResults{
			Passed:   3,
			Failed:   0,
			Coverage: 100.0,
		},
		Dependencies: []string{
			"github.com/anthonyrawlins/bzzz/sdk/bzzz",
			"github.com/anthonyrawlins/bzzz/sdk/decisions",
		},
		Language: "go",
	})
	if err != nil {
		log.Fatalf("Failed to publish decision: %v", err)
	}

	fmt.Println("✅ Decision published successfully")

	// Get connected peers
	fmt.Println("\n🌐 Getting connected peers...")
	peers, err := client.GetPeers(ctx)
	if err != nil {
		log.Printf("Warning: Failed to get peers: %v", err)
	} else {
		fmt.Printf("   Connected peers: %d\n", len(peers.ConnectedPeers))
		for _, peer := range peers.ConnectedPeers {
			fmt.Printf("   - %s (%s) - %s\n", peer.AgentID, peer.Role, peer.AuthorityLevel)
		}
	}

	// Query recent decisions
	fmt.Println("\n📊 Querying recent decisions...")
	recent, err := decisionsClient.QueryRecent(ctx, decisions.QueryRequest{
		Role:  "backend_developer",
		Limit: 5,
		Since: time.Now().Add(-24 * time.Hour),
	})
	if err != nil {
		log.Printf("Warning: Failed to query decisions: %v", err)
	} else {
		fmt.Printf("   Found %d recent decisions\n", len(recent.Decisions))
		for i, decision := range recent.Decisions {
			if i < 3 { // Show first 3
				fmt.Printf("   - %s: %s\n", decision.Task, decision.Decision)
			}
		}
	}

	fmt.Println("\n✅ Simple client example completed successfully")
}