feat: Add --limit flag to list command

Author: mybuddymichael

AGENTS.md

@@ -4,3 +4,4 @@
 - Use `mise` for all build, test, etc. commands.
 - Always run `mise run check` when you're done.
 - Use `mint` for all task tracking and issue management. Run `mint -h` to see all available commands.
+- Use `jj`, not `git`, for all git commands.

README.md

@@ -92,6 +92,21 @@ READY
    mint-j0 open Add initial code structure
 ```
 
+```bash
+→ mint list --limit 1
+READY (1 of 2)
+
+   mint-j0 open Add initial code structure
+
+BLOCKED (1 of 1)
+
+   mint-a8 open Support closing issues
+
+CLOSED (1 of 1)
+
+   mint-8G closed Write tests for closing issues
+```
+
 ```bash
 → mint update mint-a8 --comment "The problem is in main.go:123."
 Added a comment to issue mint-a8 with text "The problem is in main.go:123."

cli.go

@@ -66,6 +66,10 @@ func newCommand() *cli.Command {
 						Name:  "ready",
 						Usage: "Only show ready issues",
 					},
+					&cli.IntFlag{
+						Name:  "limit",
+						Usage: "Limit the number of issues shown per section",
+					},
 				},
 				Action: listAction,
 			},

cmd_list.go

@@ -58,6 +58,7 @@ func listAction(_ context.Context, cmd *cli.Command) error {
 
 	openOnly := cmd.Bool("open")
 	readyOnly := cmd.Bool("ready")
+	limit := cmd.Int("limit")
 
 	// Sort issues by timestamps (only what we'll display)
 	sortByCreatedAt(readyIssues)
@@ -68,11 +69,33 @@ func listAction(_ context.Context, cmd *cli.Command) error {
 		sortByUpdatedAt(closedIssues)
 	}
 
+	// Track original counts before applying limit
+	readyTotalCount := len(readyIssues)
+	blockedTotalCount := len(blockedIssues)
+	closedTotalCount := len(closedIssues)
+
+	// Apply limit to each section (if limit > 0)
+	if limit > 0 {
+		if len(readyIssues) > limit {
+			readyIssues = readyIssues[:limit]
+		}
+		if len(blockedIssues) > limit {
+			blockedIssues = blockedIssues[:limit]
+		}
+		if len(closedIssues) > limit {
+			closedIssues = closedIssues[:limit]
+		}
+	}
+
 	// Display READY section
 	if _, err := fmt.Fprintln(w); err != nil {
 		return err
 	}
 	readyHeader := "\033[48;5;2m\033[38;5;0m READY \033[0m"
+	// Add limit indicator if section is actually limited
+	if limit > 0 && len(readyIssues) < readyTotalCount {
+		readyHeader += fmt.Sprintf(" \033[38;5;8m(%d of %d)\033[0m", len(readyIssues), readyTotalCount)
+	}
 	if _, err := fmt.Fprintln(w, readyHeader); err != nil {
 		return err
 	}
@@ -97,6 +120,10 @@ func listAction(_ context.Context, cmd *cli.Command) error {
 		}
 
 		blockedHeader := "\033[48;5;1m\033[38;5;0m BLOCKED \033[0m"
+		// Add limit indicator if section is actually limited
+		if limit > 0 && len(blockedIssues) < blockedTotalCount {
+			blockedHeader += fmt.Sprintf(" \033[38;5;8m(%d of %d)\033[0m", len(blockedIssues), blockedTotalCount)
+		}
 		if _, err := fmt.Fprintln(w, blockedHeader); err != nil {
 			return err
 		}
@@ -122,6 +149,10 @@ func listAction(_ context.Context, cmd *cli.Command) error {
 		}
 
 		closedHeader := "\033[48;5;0m\033[38;5;15m CLOSED \033[0m"
+		// Add limit indicator if section is actually limited
+		if limit > 0 && len(closedIssues) < closedTotalCount {
+			closedHeader += fmt.Sprintf(" \033[38;5;8m(%d of %d)\033[0m", len(closedIssues), closedTotalCount)
+		}
 		if _, err := fmt.Fprintln(w, closedHeader); err != nil {
 			return err
 		}