Add show and settings commands with comprehensive testing (#44)

## Summary
- Implement show command with subcommands for querying individual
pomodoro attributes
- Implement settings command for displaying current configuration
- Add comprehensive test coverage for both commands including edge cases

## Changes

### New Commands
- **show <timestamp>** - Display basic pomodoro information with
optional --json and --all flags
- show duration - Display duration in various formats (mm:ss, minutes,
seconds)
  - show description - Display pomodoro description
  - show tags - Display tags with optional spacing control
- show start_time - Display start time with optional unix timestamp
format
  - show completed - Display completion status as boolean or numeric

- **settings** - Display current configuration with optional --json
output
- Shows data directory, daily goal, default durations, and default tags
  - Properly formats values according to spec

### Implementation Details
- Uses logfmt encoding for proper quoting in show command output
- Shared utility functions in cmd/util.go for JSON output and completion
checks
- Subcommands support various output format flags (--minutes, --seconds,
--unix, --raw, --numeric)
- Global flags (--format, --wait) hidden on these commands as they are
not applicable

### Testing
- Added 422 comprehensive tests in test/show.bats covering:
  - All subcommands and their flags
  - Edge cases (special characters, empty values, boundary conditions)
- Error handling (invalid timestamps, missing arguments, flag conflicts)
  - JSON output validation
  - Current vs completed pomodoro logic

- Added 128 tests in test/settings.bats covering:
  - Default values, custom settings, JSON output
  - Edge cases (malformed files, negative values, large values)
  - Default tags handling

### Dependencies
- Added github.com/go-logfmt/logfmt v0.6.0 for proper output formatting

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: justincampbell

cmd/settings.go

@@ -0,0 +1,68 @@
+package cmd
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/spf13/cobra"
+)
+
+func init() {
+	settingsCmd := &cobra.Command{
+		Use:   "settings",
+		Short: "Show current settings",
+		Long:  "Display current application settings including defaults and configuration",
+		RunE:  settingsShowCmd,
+	}
+
+	var jsonFlag bool
+	settingsCmd.Flags().BoolVarP(&jsonFlag, "json", "j", false, "output as JSON")
+
+	RootCmd.AddCommand(settingsCmd)
+
+	// Hide irrelevant global flags
+	settingsCmd.InheritedFlags().MarkHidden("format")
+	settingsCmd.InheritedFlags().MarkHidden("wait")
+}
+
+func settingsShowCmd(cmd *cobra.Command, args []string) error {
+	jsonFlag, _ := cmd.Flags().GetBool("json")
+
+	if jsonFlag {
+		return outputSettingsJSON()
+	}
+
+	fmt.Printf("data_directory=%s\n", client.Directory)
+	fmt.Printf("daily_goal=%d\n", settings.DailyGoal)
+	fmt.Printf("default_pomodoro_duration=%d\n", int(settings.DefaultPomodoroDuration.Minutes()))
+	fmt.Printf("default_break_duration=%d\n", int(settings.DefaultBreakDuration.Minutes()))
+
+	if len(settings.DefaultTags) > 0 {
+		// Format as comma-separated string like in history files
+		fmt.Printf("default_tags=%s\n", strings.Join(settings.DefaultTags, ","))
+	} else {
+		fmt.Printf("default_tags=\n")
+	}
+
+	return nil
+}
+
+type SettingsJSON struct {
+	DataDirectory           string   `json:"data_directory"`
+	DailyGoal               int      `json:"daily_goal"`
+	DefaultPomodoroDuration int      `json:"default_pomodoro_duration"` // in minutes
+	DefaultBreakDuration    int      `json:"default_break_duration"`    // in minutes
+	DefaultTags             []string `json:"default_tags"`
+}
+
+func outputSettingsJSON() error {
+	settingsData := SettingsJSON{
+		DataDirectory:           client.Directory,
+		DailyGoal:               settings.DailyGoal,
+		DefaultPomodoroDuration: int(settings.DefaultPomodoroDuration.Minutes()),
+		DefaultBreakDuration:    int(settings.DefaultBreakDuration.Minutes()),
+		DefaultTags:             settings.DefaultTags,
+	}
+
+	return printJSON(settingsData)
+}

cmd/show.go

@@ -0,0 +1,287 @@
+package cmd
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/go-logfmt/logfmt"
+	"github.com/open-pomodoro/go-openpomodoro"
+	"github.com/open-pomodoro/openpomodoro-cli/format"
+	"github.com/spf13/cobra"
+)
+
+func init() {
+	// Parent show command - shows basic info
+	showCmd := &cobra.Command{
+		Use:   "show <timestamp>",
+		Short: "Show basic details about a specific pomodoro",
+		Args:  cobra.ExactArgs(1),
+		RunE:  showBasicCmd,
+	}
+
+	// Add JSON flag to parent command (applies to basic info)
+	var jsonFlag, allFlag bool
+	showCmd.Flags().BoolVarP(&jsonFlag, "json", "j", false, "output as JSON")
+	showCmd.Flags().BoolVarP(&allFlag, "all", "a", false, "show all attributes including empty ones")
+
+	// Duration subcommand
+	durationCmd := &cobra.Command{
+		Use:   "duration <timestamp>",
+		Short: "Show pomodoro duration",
+		Args:  cobra.ExactArgs(1),
+		RunE:  showDurationCmd,
+	}
+	var minutesFlag, secondsFlag bool
+	durationCmd.Flags().BoolVarP(&minutesFlag, "minutes", "m", false, "output duration as minutes")
+	durationCmd.Flags().BoolVarP(&secondsFlag, "seconds", "s", false, "output duration as seconds")
+
+	// Description subcommand
+	descriptionCmd := &cobra.Command{
+		Use:   "description <timestamp>",
+		Short: "Show pomodoro description",
+		Args:  cobra.ExactArgs(1),
+		RunE:  showDescriptionCmd,
+	}
+
+	// Tags subcommand
+	tagsCmd := &cobra.Command{
+		Use:   "tags <timestamp>",
+		Short: "Show pomodoro tags",
+		Args:  cobra.ExactArgs(1),
+		RunE:  showTagsCmd,
+	}
+	var rawFlag bool
+	tagsCmd.Flags().BoolVar(&rawFlag, "raw", false, "raw format (no spacing)")
+
+	// Start time subcommand
+	startTimeCmd := &cobra.Command{
+		Use:   "start_time <timestamp>",
+		Short: "Show pomodoro start time",
+		Args:  cobra.ExactArgs(1),
+		RunE:  showStartTimeCmd,
+	}
+	var unixFlag bool
+	startTimeCmd.Flags().BoolVarP(&unixFlag, "unix", "u", false, "output time as unix timestamp")
+
+	// Completed subcommand
+	completedCmd := &cobra.Command{
+		Use:   "completed <timestamp>",
+		Short: "Show pomodoro completion status",
+		Args:  cobra.ExactArgs(1),
+		RunE:  showCompletedCmd,
+	}
+	var numericFlag bool
+	completedCmd.Flags().BoolVar(&numericFlag, "numeric", false, "output booleans as 1/0")
+
+	// Add subcommands to parent
+	showCmd.AddCommand(durationCmd, descriptionCmd, tagsCmd, startTimeCmd, completedCmd)
+
+	// Add to root command
+	RootCmd.AddCommand(showCmd)
+
+	// Hide irrelevant global flags after adding to root
+	showCmd.InheritedFlags().MarkHidden("format")
+	showCmd.InheritedFlags().MarkHidden("wait")
+}
+
+func showBasicCmd(cmd *cobra.Command, args []string) error {
+	timestamp := args[0]
+	jsonFlag, _ := cmd.Flags().GetBool("json")
+	allFlag, _ := cmd.Flags().GetBool("all")
+
+	p, err := findPomodoroByTimestamp(timestamp)
+	if err != nil {
+		return err
+	}
+
+	if jsonFlag {
+		return outputPomodoroJSON(p)
+	}
+
+	// Show basic info using logfmt encoding for proper quoting
+	var buf bytes.Buffer
+	enc := logfmt.NewEncoder(&buf)
+
+	enc.EncodeKeyval("start_time", p.StartTime.Format(openpomodoro.TimeFormat))
+	fmt.Println(buf.String())
+	buf.Reset()
+
+	if allFlag || p.Description != "" {
+		enc.EncodeKeyval("description", p.Description)
+		fmt.Println(buf.String())
+		buf.Reset()
+	}
+
+	enc.EncodeKeyval("duration", int(p.Duration.Minutes()))
+	fmt.Println(buf.String())
+	buf.Reset()
+
+	if allFlag || len(p.Tags) > 0 {
+		if len(p.Tags) > 0 {
+			enc.EncodeKeyval("tags", strings.Join(p.Tags, ","))
+		} else {
+			enc.EncodeKeyval("tags", "")
+		}
+		fmt.Println(buf.String())
+		buf.Reset()
+	}
+
+	return nil
+}
+
+func showDurationCmd(cmd *cobra.Command, args []string) error {
+	timestamp := args[0]
+	minutesFlag, _ := cmd.Flags().GetBool("minutes")
+	secondsFlag, _ := cmd.Flags().GetBool("seconds")
+
+	if minutesFlag && secondsFlag {
+		return errors.New("cannot use both --minutes and --seconds flags")
+	}
+
+	p, err := findPomodoroByTimestamp(timestamp)
+	if err != nil {
+		return err
+	}
+
+	if minutesFlag {
+		fmt.Println(int(p.Duration.Minutes()))
+	} else if secondsFlag {
+		fmt.Println(int(p.Duration.Seconds()))
+	} else {
+		fmt.Println(format.DurationAsTime(p.Duration))
+	}
+
+	return nil
+}
+
+func showDescriptionCmd(cmd *cobra.Command, args []string) error {
+	timestamp := args[0]
+
+	p, err := findPomodoroByTimestamp(timestamp)
+	if err != nil {
+		return err
+	}
+
+	fmt.Println(p.Description)
+	return nil
+}
+
+func showTagsCmd(cmd *cobra.Command, args []string) error {
+	timestamp := args[0]
+	rawFlag, _ := cmd.Flags().GetBool("raw")
+
+	p, err := findPomodoroByTimestamp(timestamp)
+	if err != nil {
+		return err
+	}
+
+	if rawFlag {
+		fmt.Println(strings.Join(p.Tags, ","))
+	} else {
+		fmt.Println(strings.Join(p.Tags, ", "))
+	}
+
+	return nil
+}
+
+func showStartTimeCmd(cmd *cobra.Command, args []string) error {
+	timestamp := args[0]
+	unixFlag, _ := cmd.Flags().GetBool("unix")
+
+	p, err := findPomodoroByTimestamp(timestamp)
+	if err != nil {
+		return err
+	}
+
+	if unixFlag {
+		fmt.Println(p.StartTime.Unix())
+	} else {
+		fmt.Println(p.StartTime.Format(openpomodoro.TimeFormat))
+	}
+
+	return nil
+}
+
+func showCompletedCmd(cmd *cobra.Command, args []string) error {
+	timestamp := args[0]
+	numericFlag, _ := cmd.Flags().GetBool("numeric")
+
+	p, err := findPomodoroByTimestamp(timestamp)
+	if err != nil {
+		return err
+	}
+
+	completed := isPomodoroCompleted(p)
+
+	if numericFlag {
+		if completed {
+			fmt.Println("1")
+		} else {
+			fmt.Println("0")
+		}
+	} else {
+		if completed {
+			fmt.Println("true")
+		} else {
+			fmt.Println("false")
+		}
+	}
+
+	return nil
+}
+
+func findPomodoroByTimestamp(timestampStr string) (*openpomodoro.Pomodoro, error) {
+	// Parse the timestamp
+	timestamp, err := time.Parse(openpomodoro.TimeFormat, timestampStr)
+	if err != nil {
+		return nil, fmt.Errorf("invalid timestamp format: %v", err)
+	}
+
+	// Check if it's the current pomodoro
+	current, err := client.Pomodoro()
+	if err == nil && !current.IsInactive() {
+		if current.Matches(&openpomodoro.Pomodoro{StartTime: timestamp}) {
+			return current, nil
+		}
+	}
+
+	// Search in history
+	history, err := client.History()
+	if err != nil {
+		return nil, fmt.Errorf("failed to read history: %v", err)
+	}
+
+	for _, p := range history.Pomodoros {
+		if p.Matches(&openpomodoro.Pomodoro{StartTime: timestamp}) {
+			return p, nil
+		}
+	}
+
+	return nil, fmt.Errorf("pomodoro with timestamp %s not found", timestampStr)
+}
+
+type PomodoroJSON struct {
+	StartTime   string   `json:"start_time"`
+	Description string   `json:"description"`
+	Duration    int      `json:"duration"`
+	Tags        []string `json:"tags"`
+	Completed   bool     `json:"completed"`
+	IsCurrent   bool     `json:"is_current"`
+}
+
+func outputPomodoroJSON(p *openpomodoro.Pomodoro) error {
+	completed := isPomodoroCompleted(p)
+	pomodoroData := PomodoroJSON{
+		StartTime:   p.StartTime.Format(openpomodoro.TimeFormat),
+		Description: p.Description,
+		Duration:    int(p.Duration.Minutes()),
+		Tags:        p.Tags,
+		Completed:   completed,
+		IsCurrent:   !completed,
+	}
+
+	return printJSON(pomodoroData)
+}

cmd/util.go

@@ -1,12 +1,14 @@
 package cmd
 
 import (
+	"encoding/json"
 	"fmt"
 	"strconv"
 	"time"
 
 	"github.com/justincampbell/go-countdown"
 	"github.com/justincampbell/go-countdown/format"
+	"github.com/open-pomodoro/go-openpomodoro"
 )
 
 // wait displays a countdown timer for the specified duration
@@ -28,3 +30,20 @@ func parseDurationMinutes(s string) (time.Duration, error) {
 	}
 	return time.ParseDuration(s)
 }
+
+// printJSON marshals a value as indented JSON and prints it
+func printJSON(v interface{}) error {
+	data, err := json.MarshalIndent(v, "", "  ")
+	if err != nil {
+		return err
+	}
+
+	fmt.Println(string(data))
+	return nil
+}
+
+// isPomodoroCompleted returns true if the given pomodoro is completed (not current)
+func isPomodoroCompleted(p *openpomodoro.Pomodoro) bool {
+	current, _ := client.Pomodoro()
+	return current.IsInactive() || !current.Matches(p)
+}