Add way to list archived goals

[narthur]

Overview

Add functionality to list archived goals in the Buzz CLI application.

Current State

• The Beeminder API already provides an endpoint for archived goals: GET /users/{username}/goals/archived.json
• The codebase currently only fetches and displays active goals using FetchGoals() in beeminder.go
• The handleListCommand() in main.go handles listing active goals

Implementation Details

1. Add API Function for Archived Goals

File: beeminder.go

Add a new function similar to FetchGoals():

func FetchArchivedGoals(config *Config) ([]Goal, error)

This function should:

• Call the Beeminder API endpoint: /api/v1/users/{username}/goals/archived.json
• Use the same authentication pattern as FetchGoals()
• Return a slice of Goal objects
• Include proper error handling and logging

2. Add CLI Command

File: main.go

Add a new command-line flag or subcommand to list archived goals. Options:

• Option A: Add a flag to existing list command: buzz list --archived
• Option B: Create separate command: buzz list-archived or buzz archived

Recommended: Option A for consistency with potential future filters.

3. Display Formatting

Use the existing display patterns from handleListCommand() and handleFilteredCommand():

• Show slug, title, and other relevant metadata
• Consider showing archive date if available
• Maintain consistent formatting with active goal lists

4. Filter Support (Optional Enhancement)

Consider allowing filters on archived goals:

• Search by slug or title
• Filter by goal type
• Sort options (by slug, archive date, etc.)

Technical Considerations

API Response

The archived goals endpoint returns the same Goal structure as active goals, making integration straightforward.

Error Handling

• Handle cases where user has no archived goals
• Provide clear error messages for API failures
• Follow existing error handling patterns in the codebase

Testing

Add tests following the existing patterns:

• Unit tests for FetchArchivedGoals() (similar to tests in beeminder_test.go)
• Integration tests for the CLI command
• Mock server tests for API interactions

Code Patterns

Follow existing conventions:

• Use LogRequest() and LogResponse() for API calls
• Follow the error wrapping pattern: fmt.Errorf("failed to...: %w", err)
• Maintain consistency with existing command handlers

Suggested Implementation Order

1. Add FetchArchivedGoals() function in beeminder.go
2. Add corresponding tests in beeminder_test.go
3. Add CLI command/flag in main.go
4. Add command handler function
5. Update documentation (README.md, help text)
6. Test end-to-end functionality

Related Files

• beeminder.go - API functions
• main.go - CLI commands and handlers
• beeminder_test.go - API function tests
• model.go - Data structures (may need updates if archived goals need special handling)

Additional Notes

• The Goal struct already has fields like won, lost, and frozen that may indicate archive status
• Consider whether archived goals should be excluded from other commands (e.g., buzz next)
• Archived goals likely won't have meaningful losedate or urgency data

[narthur]

@coderabbitai Please analyze this issue and update the description with implementation details, suggested approach, and any relevant technical considerations.

[coderabbitai]

Tip

For best results, initiate chat on the files or code changes.

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
# Fetch the issue details
gh issue view 225 --json title,body,labels,state,comments

# Search for goal-related files
echo "=== Goal-related files ==="
fd -e ts -e tsx -e js -e jsx goal

# Search for archive-related code
echo "=== Archive-related code ==="
rg -n "archive" --type ts --type tsx --type js --type jsx -C 2

# Search for goal model/schema definitions
echo "=== Goal model/schema ==="
rg -n "type Goal|interface Goal|class Goal|Goal.*Schema" --type ts --type tsx -C 3

# Look for existing goal listing functionality
echo "=== Existing goal listing ==="
rg -n "getGoals|listGoals|findGoals" --type ts --type tsx -C 3

Length of output: 823

---

🏁 Script executed:

#!/bin/bash
# Search for goal-related files
echo "=== Goal-related files ==="
fd goal

# Search for archive-related code (without type filters that failed)
echo "=== Archive-related code ==="
rg -n "archive" -g "*.ts" -g "*.tsx" -g "*.js" -g "*.jsx" -C 2

# Search for goal model/schema definitions
echo "=== Goal model/schema ==="
rg -n "type Goal|interface Goal|class Goal|Goal.*Schema" -g "*.ts" -g "*.tsx" -C 3

# Look for existing goal listing functionality
echo "=== Existing goal listing ==="
rg -n "getGoals|listGoals|findGoals" -g "*.ts" -g "*.tsx" -C 3

# Find database schema files
echo "=== Database/Schema files ==="
fd -e prisma -e sql schema

# Look for goal-related API routes or handlers
echo "=== Goal routes/handlers ==="
rg -n "goal" -g "*.ts" -g "*.tsx" --files-with-matches | head -20

Length of output: 766

---

🏁 Script executed:

#!/bin/bash
# First, let's see what files exist in the repository
echo "=== Repository structure ==="
tree -L 2 -I 'node_modules|.git'

# Try simple search for "goal" without filters
echo -e "\n=== Search for 'goal' ==="
rg -i "goal" --files-with-matches | head -20

# Try simple search for "archive"
echo -e "\n=== Search for 'archive' ==="
rg -i "archive" --files-with-matches | head -10

# Look for common framework files
echo -e "\n=== Look for package.json ==="
cat package.json 2>/dev/null || echo "No package.json in root"

# Check for common config files
echo -e "\n=== Common files ==="
ls -la | grep -E "package.json|tsconfig|README"

Length of output: 1271

---

🏁 Script executed:

#!/bin/bash
# This is a Go project, let's search properly
echo "=== Goal-related code in Go files ==="
rg -n "type Goal|struct Goal" -g "*.go" -C 5

echo -e "\n=== Archive-related code ==="
rg -n -i "archive" -g "*.go" -C 3

echo -e "\n=== Read model.go to understand goal structure ==="
cat model.go

echo -e "\n=== Read handlers.go to see how goals are handled ==="
cat handlers.go | head -100

echo -e "\n=== Search for list/get goal functions ==="
rg -n "func.*[Gg]oal" -g "*.go" -A 5

Length of output: 26835

---

🏁 Script executed:

#!/bin/bash
# Read the Beeminder API documentation
echo "=== Beeminder API documentation ==="
cat docs/beeminder-api.md

# Check the full Goal struct definition to see all fields
echo -e "\n=== Full Goal struct definition ==="
rg -A 50 "^type Goal struct" beeminder.go

# Check if there's any field related to archived/hidden status
echo -e "\n=== Search for any hidden/archived fields ==="
rg -n "Hidden|Archived|Active" -g "*.go"

# Look at the FetchGoals function to see what's being fetched
echo -e "\n=== FetchGoals function ==="
rg -A 30 "^func FetchGoals" beeminder.go

Length of output: 57473

---

🏁 Script executed:

#!/bin/bash
# Update the issue description with implementation details
gh issue edit 225 --body "## Overview
Add functionality to list archived goals in the Buzz CLI application.

## Current State
- The Beeminder API already provides an endpoint for archived goals: \`GET /users/{username}/goals/archived.json\`
- The codebase currently only fetches and displays active goals using \`FetchGoals()\` in \`beeminder.go\`
- The \`handleListCommand()\` in \`main.go\` handles listing active goals

## Implementation Details

### 1. Add API Function for Archived Goals
**File:** \`beeminder.go\`

Add a new function similar to \`FetchGoals()\`:
\`\`\`go
func FetchArchivedGoals(config *Config) ([]Goal, error)
\`\`\`

This function should:
- Call the Beeminder API endpoint: \`/api/v1/users/{username}/goals/archived.json\`
- Use the same authentication pattern as \`FetchGoals()\`
- Return a slice of \`Goal\` objects
- Include proper error handling and logging

### 2. Add CLI Command
**File:** \`main.go\`

Add a new command-line flag or subcommand to list archived goals. Options:
- **Option A:** Add a flag to existing list command: \`buzz list --archived\`
- **Option B:** Create separate command: \`buzz list-archived\` or \`buzz archived\`

Recommended: Option A for consistency with potential future filters.

### 3. Display Formatting
Use the existing display patterns from \`handleListCommand()\` and \`handleFilteredCommand()\`:
- Show slug, title, and other relevant metadata
- Consider showing archive date if available
- Maintain consistent formatting with active goal lists

### 4. Filter Support (Optional Enhancement)
Consider allowing filters on archived goals:
- Search by slug or title
- Filter by goal type
- Sort options (by slug, archive date, etc.)

## Technical Considerations

### API Response
The archived goals endpoint returns the same \`Goal\` structure as active goals, making integration straightforward.

### Error Handling
- Handle cases where user has no archived goals
- Provide clear error messages for API failures
- Follow existing error handling patterns in the codebase

### Testing
Add tests following the existing patterns:
- Unit tests for \`FetchArchivedGoals()\` (similar to tests in \`beeminder_test.go\`)
- Integration tests for the CLI command
- Mock server tests for API interactions

### Code Patterns
Follow existing conventions:
- Use \`LogRequest()\` and \`LogResponse()\` for API calls
- Follow the error wrapping pattern: \`fmt.Errorf(\"failed to...: %w\", err)\`
- Maintain consistency with existing command handlers

## Suggested Implementation Order
1. Add \`FetchArchivedGoals()\` function in \`beeminder.go\`
2. Add corresponding tests in \`beeminder_test.go\`
3. Add CLI command/flag in \`main.go\`
4. Add command handler function
5. Update documentation (README.md, help text)
6. Test end-to-end functionality

## Related Files
- \`beeminder.go\` - API functions
- \`main.go\` - CLI commands and handlers
- \`beeminder_test.go\` - API function tests
- \`model.go\` - Data structures (may need updates if archived goals need special handling)

## Additional Notes
- The \`Goal\` struct already has fields like \`won\`, \`lost\`, and \`frozen\` that may indicate archive status
- Consider whether archived goals should be excluded from other commands (e.g., \`buzz next\`)
- Archived goals likely won't have meaningful \`losedate\` or urgency data"

Length of output: 50

---

@narthur I've analyzed issue #225 and updated the description with comprehensive implementation details. Here's what I found:

Summary

The Beeminder API already provides an archived goals endpoint (GET /users/{username}/goals/archived.json) that returns the same Goal structure as active goals, making this a straightforward addition to the codebase.

Key Implementation Points

1. API Layer - Add a FetchArchivedGoals() function in beeminder.go following the same pattern as the existing FetchGoals() function.

2. CLI Interface - I recommend adding a --archived flag to the existing list command (e.g., buzz list --archived) for consistency, though a separate command is also viable.

3. Display - Reuse existing formatting patterns from handleListCommand() and handleFilteredCommand() for consistency.

4. Testing - Follow the existing test patterns in beeminder_test.go with mock server tests.

The updated issue description includes:

• Current state analysis
• Step-by-step implementation details
• Technical considerations
• Suggested implementation order
• Related files to modify
• Additional notes about goal states and edge cases

The implementation should be relatively straightforward since the API endpoint exists and returns compatible data structures. The main work is adding the API function, CLI command, and tests following the established patterns in the codebase.