+199 -60

handler/main.go

··· 13 13 14 14 "github.com/spf13/cobra" 15 15 "github.com/taciturnaxolotl/akami/styles" 16 16 + "github.com/taciturnaxolotl/akami/utils" 16 17 "github.com/taciturnaxolotl/akami/wakatime" 17 18 "gopkg.in/ini.v1" 18 19 ) ··· 130 131 Time: float64(time.Now().Unix()), 131 132 } 132 133 134 134 + func getClientStuff(c *cobra.Command) (key string, url string, err error) { 135 135 + configApiKey, _ := c.Flags().GetString("key") 136 136 + configApiURL, _ := c.Flags().GetString("url") 137 137 + 138 138 + // If either value is missing, try to load from config file 139 139 + if configApiKey == "" || configApiURL == "" { 140 140 + userDir, err := os.UserHomeDir() 141 141 + if err != nil { 142 142 + errorTask(c, "Validating arguments") 143 143 + return configApiKey, configApiURL, err 144 144 + } 145 145 + wakatimePath := filepath.Join(userDir, ".wakatime.cfg") 146 146 + 147 147 + cfg, err := ini.Load(wakatimePath) 148 148 + if err != nil { 149 149 + errorTask(c, "Validating arguments") 150 150 + return configApiKey, configApiURL, errors.New("config file not found and you haven't passed all arguments") 151 151 + } 152 152 + 153 153 + settings, err := cfg.GetSection("settings") 154 154 + if err != nil { 155 155 + errorTask(c, "Validating arguments") 156 156 + return configApiKey, configApiURL, errors.New("no settings section in your config") 157 157 + } 158 158 + 159 159 + // Only load from config if not provided as parameter 160 160 + if configApiKey == "" { 161 161 + configApiKey = settings.Key("api_key").String() 162 162 + if configApiKey == "" { 163 163 + errorTask(c, "Validating arguments") 164 164 + return configApiKey, configApiURL, errors.New("couldn't find an api_key in your config") 165 165 + } 166 166 + } 167 167 + 168 168 + if configApiURL == "" { 169 169 + configApiURL = settings.Key("api_url").String() 170 170 + if configApiURL == "" { 171 171 + errorTask(c, "Validating arguments") 172 172 + return configApiKey, configApiURL, errors.New("couldn't find an api_url in your config") 173 173 + } 174 174 + } 175 175 + } 176 176 + 177 177 + return configApiKey, configApiURL, nil 178 178 + } 179 179 + 133 180 func Doctor(c *cobra.Command, _ []string) error { 134 181 // Initialize a new context with task state 135 182 c.SetContext(context.WithValue(context.Background(), "taskState", &taskState{})) ··· 225 272 } 226 273 completeTask(c, "Checking your coding stats for today") 227 274 228 228 - // Convert seconds to a formatted time string (hours, minutes, seconds) 229 229 - totalSeconds := duration.Data.GrandTotal.TotalSeconds 230 230 - hours := totalSeconds / 3600 231 231 - minutes := (totalSeconds % 3600) / 60 232 232 - seconds := totalSeconds % 60 233 233 - 234 234 - formattedTime := "" 235 235 - if hours > 0 { 236 236 - formattedTime += fmt.Sprintf("%d hours, ", hours) 237 237 - } 238 238 - if minutes > 0 || hours > 0 { 239 239 - formattedTime += fmt.Sprintf("%d minutes, ", minutes) 240 240 - } 241 241 - formattedTime += fmt.Sprintf("%d seconds", seconds) 242 242 - 243 243 - c.Printf("Sweet!!! Looks like your hackatime is configured properly! Looks like you have coded today for %s\n\n", styles.Fancy.Render(formattedTime)) 275 275 + c.Printf("Sweet!!! Looks like your hackatime is configured properly! Looks like you have coded today for %s\n\n", styles.Fancy.Render(utils.PrettyPrintTime(duration.Data.GrandTotal.TotalSeconds))) 244 276 245 277 printTask(c, "Sending test heartbeat") 246 278 ··· 262 294 263 295 printTask(c, "Validating arguments") 264 296 265 265 - configApiKey, _ := c.Flags().GetString("key") 266 266 - configApiURL, _ := c.Flags().GetString("url") 267 267 - 268 268 - // If either value is missing, try to load from config file 269 269 - if configApiKey == "" || configApiURL == "" { 270 270 - userDir, err := os.UserHomeDir() 271 271 - if err != nil { 272 272 - errorTask(c, "Validating arguments") 273 273 - return err 274 274 - } 275 275 - wakatimePath := filepath.Join(userDir, ".wakatime.cfg") 276 276 - 277 277 - cfg, err := ini.Load(wakatimePath) 278 278 - if err != nil { 279 279 - errorTask(c, "Validating arguments") 280 280 - return errors.New("config file not found and you haven't passed all arguments") 281 281 - } 282 282 - 283 283 - settings, err := cfg.GetSection("settings") 284 284 - if err != nil { 285 285 - errorTask(c, "Validating arguments") 286 286 - return errors.New("no settings section in your config") 287 287 - } 288 288 - 289 289 - // Only load from config if not provided as parameter 290 290 - if configApiKey == "" { 291 291 - configApiKey = settings.Key("api_key").String() 292 292 - if configApiKey == "" { 293 293 - errorTask(c, "Validating arguments") 294 294 - return errors.New("couldn't find an api_key in your config") 295 295 - } 296 296 - } 297 297 - 298 298 - if configApiURL == "" { 299 299 - configApiURL = settings.Key("api_url").String() 300 300 - if configApiURL == "" { 301 301 - errorTask(c, "Validating arguments") 302 302 - return errors.New("couldn't find an api_url in your config") 303 303 - } 304 304 - } 305 305 - } 297 297 + api_key, api_url, err := getClientStuff(c) 306 298 307 299 completeTask(c, "Arguments look fine!") 308 300 309 301 printTask(c, "Loading api client") 310 302 311 311 - client := wakatime.NewClientWithOptions(configApiKey, configApiURL) 312 312 - _, err := client.GetStatusBar() 303 303 + client := wakatime.NewClientWithOptions(api_key, api_url) 304 304 + _, err = client.GetStatusBar() 313 305 if err != nil { 314 306 errorTask(c, "Loading api client") 315 307 return err ··· 317 309 318 310 completeTask(c, "Loading api client") 319 311 320 320 - c.Println("Sending a test heartbeat to", styles.Muted.Render(configApiURL)) 312 312 + c.Println("Sending a test heartbeat to", styles.Muted.Render(api_url)) 321 313 322 314 printTask(c, "Sending test heartbeat") 323 315 ··· 334 326 335 327 return nil 336 328 } 329 329 + 330 330 + func Status(c *cobra.Command, args []string) error { 331 331 + // Initialize a new context with task state 332 332 + c.SetContext(context.WithValue(context.Background(), "taskState", &taskState{})) 333 333 + 334 334 + printTask(c, "Validating arguments") 335 335 + 336 336 + api_key, api_url, err := getClientStuff(c) 337 337 + 338 338 + completeTask(c, "Arguments look fine!") 339 339 + 340 340 + printTask(c, "Loading api client") 341 341 + 342 342 + client := wakatime.NewClientWithOptions(api_key, api_url) 343 343 + status, err := client.GetStatusBar() 344 344 + if err != nil { 345 345 + errorTask(c, "Loading api client") 346 346 + return err 347 347 + } 348 348 + 349 349 + completeTask(c, "Loading api client") 350 350 + 351 351 + c.Printf("\nLooks like you have coded today for %s today!\n", styles.Fancy.Render(utils.PrettyPrintTime(status.Data.GrandTotal.TotalSeconds))) 352 352 + 353 353 + summary, err := client.GetLast7Days() 354 354 + if err != nil { 355 355 + return err 356 356 + } 357 357 + 358 358 + c.Printf("You have averaged %s over the last 7 days\n\n", styles.Fancy.Render(utils.PrettyPrintTime(int(summary.Data.DailyAverage)))) 359 359 + 360 360 + // Display top 5 projects with progress bars 361 361 + if len(summary.Data.Projects) > 0 { 362 362 + c.Println(styles.Fancy.Render("Top Projects:")) 363 363 + 364 364 + // Determine how many projects to show (up to 5) 365 365 + count := min(5, len(summary.Data.Projects)) 366 366 + 367 367 + // Find the longest project name for formatting 368 368 + longestName := 0 369 369 + longestTime := 0 370 370 + 371 371 + for i := range count { 372 372 + project := summary.Data.Projects[i] 373 373 + if len(project.Name) > longestName { 374 374 + longestName = len(project.Name) 375 375 + } 376 376 + 377 377 + timeStr := utils.PrettyPrintTime(int(project.TotalSeconds)) 378 378 + if len(timeStr) > longestTime { 379 379 + longestTime = len(timeStr) 380 380 + } 381 381 + } 382 382 + 383 383 + // Display each project with a bar 384 384 + for i := range count { 385 385 + project := summary.Data.Projects[i] 386 386 + 387 387 + // Format the project name and time with padding 388 388 + paddedName := fmt.Sprintf("%-*s", longestName+2, project.Name) 389 389 + timeStr := utils.PrettyPrintTime(int(project.TotalSeconds)) 390 390 + paddedTime := fmt.Sprintf("%-*s", longestTime+2, timeStr) 391 391 + 392 392 + // Create the progress bar 393 393 + barWidth := 25 394 394 + bar := "" 395 395 + percentage := project.Percent 396 396 + for j := range barWidth { 397 397 + if float64(j) < percentage/(100/float64(barWidth)) { 398 398 + bar += "█" 399 399 + } else { 400 400 + bar += "░" 401 401 + } 402 402 + } 403 403 + 404 404 + // Use different styles for different components 405 405 + styledName := styles.Fancy.Render(paddedName) 406 406 + styledTime := styles.Muted.Render(paddedTime) 407 407 + styledBar := styles.Success.Render(bar) 408 408 + styledPercent := styles.Warn.Render(fmt.Sprintf("%.2f%%", percentage)) 409 409 + 410 410 + // Print the formatted line 411 411 + c.Printf(" %s %s %s %s\n", styledName, styledTime, styledBar, styledPercent) 412 412 + } 413 413 + 414 414 + c.Println() 415 415 + } 416 416 + 417 417 + // Display top 5 languages with progress bars 418 418 + if len(summary.Data.Languages) > 0 { 419 419 + c.Println(styles.Fancy.Render("Top Languages:")) 420 420 + 421 421 + // Determine how many languages to show (up to 5) 422 422 + count := min(5, len(summary.Data.Languages)) 423 423 + 424 424 + // Find the longest language name for formatting 425 425 + longestName := 0 426 426 + longestTime := 0 427 427 + 428 428 + for i := range count { 429 429 + language := summary.Data.Languages[i] 430 430 + if len(language.Name) > longestName { 431 431 + longestName = len(language.Name) 432 432 + } 433 433 + 434 434 + timeStr := utils.PrettyPrintTime(int(language.TotalSeconds)) 435 435 + if len(timeStr) > longestTime { 436 436 + longestTime = len(timeStr) 437 437 + } 438 438 + } 439 439 + 440 440 + // Display each language with a bar 441 441 + for i := range count { 442 442 + language := summary.Data.Languages[i] 443 443 + 444 444 + // Format the language name and time with padding 445 445 + paddedName := fmt.Sprintf("%-*s", longestName+2, language.Name) 446 446 + timeStr := utils.PrettyPrintTime(int(language.TotalSeconds)) 447 447 + paddedTime := fmt.Sprintf("%-*s", longestTime+2, timeStr) 448 448 + 449 449 + // Create the progress bar 450 450 + barWidth := 25 451 451 + bar := "" 452 452 + percentage := language.Percent 453 453 + for j := range barWidth { 454 454 + if float64(j) < percentage/(100/float64(barWidth)) { 455 455 + bar += "█" 456 456 + } else { 457 457 + bar += "░" 458 458 + } 459 459 + } 460 460 + 461 461 + // Use different styles for different components 462 462 + styledName := styles.Fancy.Render(paddedName) 463 463 + styledTime := styles.Muted.Render(paddedTime) 464 464 + styledBar := styles.Success.Render(bar) 465 465 + styledPercent := styles.Warn.Render(fmt.Sprintf("%.2f%%", percentage)) 466 466 + 467 467 + // Print the formatted line 468 468 + c.Printf(" %s %s %s %s\n", styledName, styledTime, styledBar, styledPercent) 469 469 + } 470 470 + 471 471 + c.Println() 472 472 + } 473 473 + 474 474 + return nil 475 475 + }

+13 -5

main.go

··· 30 30 Use: "doc", 31 31 Short: "diagnose potential hackatime issues", 32 32 RunE: handler.Doctor, 33 33 + Args: cobra.NoArgs, 33 34 }) 34 35 35 35 - cmdTest := &cobra.Command{ 36 36 + cmd.AddCommand(&cobra.Command{ 36 37 Use: "test", 37 38 Short: "send a test heartbeat to hackatime or whatever api url you provide", 38 39 RunE: handler.TestHeartbeat, 39 40 Args: cobra.NoArgs, 40 40 - } 41 41 - cmdTest.Flags().StringP("url", "u", "", "The base url for the hackatime client") 42 42 - cmdTest.Flags().StringP("key", "k", "", "API key to use for authentication") 43 43 - cmd.AddCommand(cmdTest) 41 41 + }) 42 42 + 43 43 + cmd.AddCommand(&cobra.Command{ 44 44 + Use: "status", 45 45 + Short: "get your hackatime stats", 46 46 + RunE: handler.Status, 47 47 + Args: cobra.NoArgs, 48 48 + }) 49 49 + 50 50 + cmd.PersistentFlags().StringP("url", "u", "", "The base url for the hackatime client") 51 51 + cmd.PersistentFlags().StringP("key", "k", "", "API key to use for authentication") 44 52 45 53 // this is where we get the fancy fang magic ✨ 46 54 if err := fang.Execute(

+22

utils/main.go

··· 1 1 + package utils 2 2 + 3 3 + import ( 4 4 + "fmt" 5 5 + ) 6 6 + 7 7 + func PrettyPrintTime(totalSeconds int) string { 8 8 + hours := totalSeconds / 3600 9 9 + minutes := (totalSeconds % 3600) / 60 10 10 + seconds := totalSeconds % 60 11 11 + 12 12 + formattedTime := "" 13 13 + if hours > 0 { 14 14 + formattedTime += fmt.Sprintf("%d hours, ", hours) 15 15 + } 16 16 + if minutes > 0 || hours > 0 { 17 17 + formattedTime += fmt.Sprintf("%d minutes, ", minutes) 18 18 + } 19 19 + formattedTime += fmt.Sprintf("%d seconds", seconds) 20 20 + 21 21 + return formattedTime 22 22 + }

+89

wakatime/main.go

··· 212 212 213 213 return durationResp, nil 214 214 } 215 215 + 216 216 + // Last7DaysResponse represents the response from the WakaTime Last 7 Days API endpoint. 217 217 + // This contains detailed information about a user's coding activity over the past 7 days. 218 218 + type Last7DaysResponse struct { 219 219 + // Data contains coding statistics for the last 7 days 220 220 + Data struct { 221 221 + // TotalSeconds is the total time spent coding in seconds 222 222 + TotalSeconds float64 `json:"total_seconds"` 223 223 + // HumanReadableTotal is the human-readable representation of the total coding time 224 224 + HumanReadableTotal string `json:"human_readable_total"` 225 225 + // DailyAverage is the average time spent coding per day in seconds 226 226 + DailyAverage float64 `json:"daily_average"` 227 227 + // HumanReadableDailyAverage is the human-readable representation of the daily average 228 228 + HumanReadableDailyAverage string `json:"human_readable_daily_average"` 229 229 + // Languages is a list of programming languages used with statistics 230 230 + Languages []struct { 231 231 + // Name is the programming language name 232 232 + Name string `json:"name"` 233 233 + // TotalSeconds is the time spent coding in this language in seconds 234 234 + TotalSeconds float64 `json:"total_seconds"` 235 235 + // Percent is the percentage of time spent in this language 236 236 + Percent float64 `json:"percent"` 237 237 + // Text is the human-readable representation of time spent in this language 238 238 + Text string `json:"text"` 239 239 + } `json:"languages"` 240 240 + // Editors is a list of editors used with statistics 241 241 + Editors []struct { 242 242 + // Name is the editor name 243 243 + Name string `json:"name"` 244 244 + // TotalSeconds is the time spent using this editor in seconds 245 245 + TotalSeconds float64 `json:"total_seconds"` 246 246 + // Percent is the percentage of time spent using this editor 247 247 + Percent float64 `json:"percent"` 248 248 + // Text is the human-readable representation of time spent using this editor 249 249 + Text string `json:"text"` 250 250 + } `json:"editors"` 251 251 + // Projects is a list of projects worked on with statistics 252 252 + Projects []struct { 253 253 + // Name is the project name 254 254 + Name string `json:"name"` 255 255 + // TotalSeconds is the time spent on this project in seconds 256 256 + TotalSeconds float64 `json:"total_seconds"` 257 257 + // Percent is the percentage of time spent on this project 258 258 + Percent float64 `json:"percent"` 259 259 + // Text is the human-readable representation of time spent on this project 260 260 + Text string `json:"text"` 261 261 + } `json:"projects"` 262 262 + } `json:"data"` 263 263 + } 264 264 + 265 265 + // GetLast7Days retrieves a user's coding activity summary for the past 7 days from the WakaTime API. 266 266 + // It returns a Last7DaysResponse and an error if the request fails or returns a non-success status code. 267 267 + func (c *Client) GetLast7Days() (Last7DaysResponse, error) { 268 268 + req, err := http.NewRequest("GET", fmt.Sprintf("%s/users/current/stats/last_7_days", c.APIURL), nil) 269 269 + if err != nil { 270 270 + return Last7DaysResponse{}, fmt.Errorf("%w: %v", ErrCreatingRequest, err) 271 271 + } 272 272 + 273 273 + req.Header.Set("Accept", "application/json") 274 274 + req.Header.Set("Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte(c.APIKey))) 275 275 + 276 276 + resp, err := c.HTTPClient.Do(req) 277 277 + if err != nil { 278 278 + return Last7DaysResponse{}, fmt.Errorf("%w: %v", ErrSendingRequest, err) 279 279 + } 280 280 + defer resp.Body.Close() 281 281 + 282 282 + // Read the response body for potential error messages 283 283 + var respBody bytes.Buffer 284 284 + _, err = respBody.ReadFrom(resp.Body) 285 285 + if err != nil { 286 286 + return Last7DaysResponse{}, fmt.Errorf("failed to read response body: %v", err) 287 287 + } 288 288 + 289 289 + respContent := respBody.String() 290 290 + 291 291 + if resp.StatusCode == http.StatusUnauthorized { 292 292 + return Last7DaysResponse{}, fmt.Errorf("%w: %s", ErrUnauthorized, respContent) 293 293 + } else if resp.StatusCode < 200 || resp.StatusCode >= 300 { 294 294 + return Last7DaysResponse{}, fmt.Errorf("%w: status code %d, response: %s", ErrInvalidStatusCode, resp.StatusCode, respContent) 295 295 + } 296 296 + 297 297 + var statsResp Last7DaysResponse 298 298 + if err := json.Unmarshal(respBody.Bytes(), &statsResp); err != nil { 299 299 + return Last7DaysResponse{}, fmt.Errorf("%w: %v, response: %s", ErrDecodingResponse, err, respContent) 300 300 + } 301 301 + 302 302 + return statsResp, nil 303 303 + }