Initialize Bitcoin Price Tracker project with core functionality

- Added .gitignore to exclude build artifacts and environment files.
- Created go.mod for module management.
- Implemented main application logic in main.go for fetching and displaying Bitcoin prices.
- Developed tracker package with functionality for price tracking, including API interaction and data models.
- Added README.md with project objectives, features, and implementation plan.
- Set up basic error handling and graceful shutdown for the application.

Author: helioLJ

.gitignore

@@ -0,0 +1,25 @@
+# If you prefer the allow list template instead of the deny list, see community template:
+# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
+#
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/
+
+# Go workspace file
+go.work
+go.work.sum
+
+# env file
+.env

README.md

@@ -0,0 +1,117 @@
+## **Project Title**: Bitcoin Price Tracker
+
+### **Objective**
+Develop a Go-based command-line application (CLI) that allows users to:
+1. Fetch and display real-time Bitcoin prices in multiple currencies.
+2. Periodically update prices and notify users of significant changes.
+3. Log historical prices to a local file for review.
+
+---
+
+### **Features**
+1. **Fetch Current Prices**:
+   - Retrieve real-time Bitcoin prices in user-specified currencies using a public API.
+   
+2. **Periodic Updates**:
+   - Continuously fetch and update Bitcoin prices at configurable intervals using goroutines.
+
+3. **Price Alerts**:
+   - Notify the user when Bitcoin prices cross specified thresholds.
+
+4. **Historical Logging**:
+   - Log price data to a local file with timestamps for future analysis.
+
+---
+
+### **Go Concepts Incorporated**
+1. **Imports/Packages**:
+   - Utilize standard libraries (`net/http`, `encoding/json`, `os`, `time`) and third-party packages as needed (e.g., `github.com/joho/godotenv` for managing API keys).
+
+2. **Structs/Methods**:
+   - Create structs for price data and configuration settings.
+   - Define methods to fetch prices, format output, and handle updates.
+
+3. **Error Handling**:
+   - Gracefully manage HTTP request errors, JSON parsing issues, and file I/O problems.
+   - Display meaningful messages to users for troubleshooting.
+
+4. **Go Routines**:
+   - Fetch Bitcoin prices concurrently without blocking user inputs.
+   - Allow for background tasks like logging and threshold monitoring.
+
+5. **Channels**:
+   - Use channels for inter-goroutine communication, enabling real-time price updates and alerts.
+
+---
+
+### **Advanced Go Concepts (Optional)**
+1. **cgo**: 
+   - Add optional high-performance computation for price trend analysis.
+2. **Generics**: 
+   - Implement generic methods for handling API responses or data transformations.
+3. **Iterators**:
+   - Use iterators for managing and displaying logged price history.
+
+---
+
+### **Project Structure**
+```plaintext
+bitcoin-tracker/
+├── main.go           # Entry point of the application
+├── tracker/
+│   ├── tracker.go    # Logic for Bitcoin price tracking
+│   ├── models.go     # Structs for price data and alerts
+│   ├── api.go        # API interaction logic
+├── utils/
+│   ├── error.go      # Error handling utilities
+│   ├── config.go     # Environment variable handling
+├── .env              # API keys and config
+└── go.mod            # Go module definition
+```
+
+---
+
+### **Implementation Plan**
+
+#### **1. Core Features Implementation**
+1. Fetch real-time Bitcoin prices using a public API (e.g., CoinGecko or CoinMarketCap).
+2. Log historical data in a human-readable format.
+
+#### **2. Application Flow**
+1. **User Input**:
+   - Select currency for price tracking.
+   - Set optional price thresholds for alerts.
+2. **Concurrent Operations**:
+   - Run real-time price updates in a background goroutine.
+3. **Display Results**:
+   - Continuously update the terminal with the latest price and any alerts.
+
+#### **3. Incorporate Go Concepts**
+1. **Imports/Packages**:
+   - Use Go modules for managing dependencies and clean code organization.
+2. **Structs/Methods**:
+   - Define reusable structs for price data and configuration.
+3. **Error Handling**:
+   - Implement proper error handling for all operations.
+4. **Go Routines**:
+   - Fetch price data and monitor thresholds concurrently.
+5. **Channels**:
+   - Use channels to coordinate data fetching and alert notifications.
+
+---
+
+### **Stretch Goals**
+- Add support for multiple cryptocurrencies (e.g., Ethereum, Litecoin).
+- Implement a simple web server to display real-time prices using `net/http`.
+- Use a visualization library to generate charts of historical price trends.
+
+---
+
+### **Deliverables**
+1. A functional CLI application for Bitcoin price tracking.
+2. Code that demonstrates mastery of Go basics:
+   - Imports/Packages
+   - Structs/Methods
+   - Error Handling
+   - Goroutines and Channels
+3. Documentation for setup, usage, and an explanation of the Go concepts used.

go.mod

@@ -0,0 +1,3 @@
+module bitcoin-tracker
+
+go 1.23.3

main.go

@@ -0,0 +1,54 @@
+package main
+
+import (
+	"bitcoin-tracker/tracker"
+	"fmt"
+	"log"
+	"os"
+	"os/signal"
+	"strings"
+	"syscall"
+	"time"
+)
+
+func main() {
+	fmt.Println("🪙 Bitcoin Price Tracker")
+	fmt.Println("----------------------")
+	fmt.Print("Enter currency code (e.g., usd, eur, gbp): ")
+	
+	var currency string
+	fmt.Scanln(&currency)
+	
+	currency = strings.ToLower(strings.TrimSpace(currency))
+	if currency == "" {
+		currency = "usd"  // Default to USD if no input
+	}
+
+	config := tracker.Config{
+		UpdateInterval: 30 * time.Second,
+		Currency:      currency,
+	}
+
+	t := tracker.NewTracker(config)
+	t.Start()
+
+	// Handle graceful shutdown
+	sigChan := make(chan os.Signal, 1)
+	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
+
+	// Main loop
+	for {
+		select {
+		case price := <-t.GetPriceChan():
+			fmt.Printf("Bitcoin price: %.2f %s at %s\n", price.Price, price.Currency, price.Timestamp.Format(time.RFC3339))
+
+		case err := <-t.GetErrorChan():
+			log.Printf("Error: %v\n", err)
+
+		case <-sigChan:
+			fmt.Println("\nShutting down...")
+			t.Stop()
+			os.Exit(0)
+		}
+	}
+}

tracker/api.go

@@ -0,0 +1,40 @@
+package tracker
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"time"
+)
+
+const COINGECKO_API_URL = "https://api.coingecko.com/api/v3"
+
+type CoinGeckoResponse struct {
+	Bitcoin map[string]float64 `json:"bitcoin"`
+}
+
+func FetchBitcoinPrice(currency string) (*PriceData, error) {
+	url := fmt.Sprintf("%s/simple/price?ids=bitcoin&vs_currencies=%s", COINGECKO_API_URL, currency)
+
+	resp, err := http.Get(url)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch price: %v", err)
+	}
+	defer resp.Body.Close()
+
+	var data CoinGeckoResponse
+	if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %v", err)
+	}
+
+	price, ok := data.Bitcoin[currency]
+	if !ok {
+		return nil, fmt.Errorf("price not found for currency: %s", currency)
+	}
+
+	return &PriceData{
+		Price:     price,
+		Currency:  currency,
+		Timestamp: time.Now(),
+	}, nil
+}

tracker/models.go

@@ -0,0 +1,25 @@
+package tracker
+
+import "time"
+
+// PriceData represents the Bitcoin price information
+type PriceData struct {
+	Price     float64
+	Currency  string
+	Timestamp time.Time
+}
+
+// Config represents the application configuration
+type Config struct {
+	UpdateInterval time.Duration
+	Currency       string
+	AlertThreshold float64
+	APIKey         string
+}
+
+// Alert represents a price alert configuration
+type Alert struct {
+	Type      string // "above" or "below"
+	Threshold float64
+	Triggered bool
+}

tracker/tracker.go

@@ -0,0 +1,75 @@
+package tracker
+
+import (
+	"fmt"
+	"time"
+)
+
+type Tracker struct {
+	config    Config
+	alerts    []Alert
+	priceChan chan PriceData
+	errorChan chan error
+	stopChan  chan struct{}
+}
+
+func NewTracker(config Config) *Tracker {
+	return &Tracker{
+		config:    config,
+		alerts:    make([]Alert, 0),
+		priceChan: make(chan PriceData),
+		errorChan: make(chan error),
+		stopChan:  make(chan struct{}),
+	}
+}
+
+func (t *Tracker) Start() {
+	go t.trackPrices()
+}
+
+func (t *Tracker) Stop() {
+	close(t.stopChan)
+}
+
+func (t *Tracker) trackPrices() {
+	ticker := time.NewTicker(t.config.UpdateInterval)
+	defer ticker.Stop()
+
+	fmt.Printf("🔄 Fetching Bitcoin price every %v...\n", t.config.UpdateInterval)
+	fmt.Println("Press Ctrl+C to exit")
+
+	// Fetch immediately first
+	fmt.Print("Fetching latest price... ")
+	if price, err := FetchBitcoinPrice(t.config.Currency); err != nil {
+		fmt.Println("❌")
+		t.errorChan <- err
+	} else {
+		fmt.Println("✅")
+		t.priceChan <- *price
+	}
+
+	for {
+		select {
+		case <-ticker.C:
+			fmt.Print("Fetching latest price... ")
+			price, err := FetchBitcoinPrice(t.config.Currency)
+			if err != nil {
+				fmt.Println("❌")
+				t.errorChan <- err
+				continue
+			}
+			fmt.Println("✅")
+			t.priceChan <- *price
+		case <-t.stopChan:
+			return
+		}
+	}
+}
+
+func (t *Tracker) GetPriceChan() <-chan PriceData {
+	return t.priceChan
+}
+
+func (t *Tracker) GetErrorChan() <-chan error {
+	return t.errorChan
+}