feat(dates): add --due and --defer timestamp options with natural language parsing (#847)
* feat(dates): add due date schema and --due flag - Add due_at and defer_until columns to issues table via migration 035 - Implement --due flag on create command with ISO date parsing - Extend RPC protocol and daemon to pass DueAt from CLI to storage - Display DueAt and DeferUntil in show command output - Update Issue type with new date fields Users can now set due dates when creating issues, enabling deadline-based task management. * feat(dates): add compact duration parser (+6h, +1d, +2w) - Create internal/timeparsing package with layered parser architecture - Implement parseCompactDuration with regex pattern [+-]?\d+[hdwmy] - Add comprehensive test suite (22 cases) for duration parsing - Integrate into create.go with fallback to ISO format Supports hours (h), days (d), weeks (w), months (m), and years (y). Negative values allowed for past dates. * feat(dates): add NLP parsing for natural language dates Integrate olebedev/when library for natural language time expressions. The layered parser now handles: compact duration → absolute formats → NLP. Changes: - Add olebedev/when dependency for NLP parsing - Implement ParseNaturalLanguage and ParseRelativeTime functions - Reorder layers: absolute formats before NLP to avoid misinterpretation - Simplify create.go to use unified ParseRelativeTime - Add comprehensive NLP test coverage (22 test cases) Supports: tomorrow, next monday, in 3 days, 3 days ago * feat(dates): add --defer flag to create/update/defer commands Add time-based deferral support alongside existing status-based defer. Issues can now be hidden from bd ready until a specific time. Changes: - Add --defer flag to bd create (sets defer_until on creation) - Add --due and --defer flags to bd update (modify existing issues) - Add --until flag to bd defer (combines status=deferred with defer_until) - Add DueAt/DeferUntil fields to UpdateArgs in protocol.go Supports: +1h, tomorrow, next monday, 2025-01-15 * feat(dates): add defer_until filtering to ready command Add time-based deferral support to bd ready: - Add --include-deferred flag to show issues with future defer_until - Filter out issues where defer_until > now by default - Update undefer to clear defer_until alongside status change - Add IncludeDeferred to WorkFilter and RPC ReadyArgs Part of GH#820: Relative Date Parsing (Phase 5) * feat(dates): add polish and tests for relative date parsing Add user-facing warnings when defer date is in the past to help catch common mistakes. Expand help text with format examples and document the olebedev/when September parsing quirk. Tests: - TestCreateSuite/WithDueAt, WithDeferUntil, WithBothDueAndDefer - TestReadyWorkDeferUntil (ExcludesFutureDeferredByDefault, IncludeDeferredShowsAll) Docs: - CLAUDE.md quick reference updated with new flags - Help text examples for --due, --defer on create/update Closes: Phase 6 of beads-820-relative-dates spec * feat(list): add time-based query filters for defer/due dates Add --deferred, --defer-before, --defer-after, --due-before, --due-after, and --overdue flags to bd list command. All date filters now support relative time expressions (+6h, tomorrow, next monday) via the timeparsing package. Filters: - --deferred: issues with defer_until set - --defer-before/after: filter by defer_until date range - --due-before/after: filter by due_at date range - --overdue: due_at in past AND status != closed Existing date filters (--created-after, etc.) now also support relative time expressions through updated parseTimeFlag(). * build(nix): update vendorHash for olebedev/when dependency The olebedev/when library was added for natural language date parsing (GH#820). This changes go.sum, requiring an updated vendorHash in the Nix flake configuration.
This commit is contained in:
Peter Chanthamynavong
committed by
GitHub
GitHub
parent
e4042e3e1a
commit
d371baf2ca
@@ -6,6 +6,7 @@ import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/spf13/cobra"
|
||||
"github.com/steveyegge/beads/internal/config"
|
||||
@@ -14,6 +15,7 @@ import (
|
||||
"github.com/steveyegge/beads/internal/routing"
|
||||
"github.com/steveyegge/beads/internal/rpc"
|
||||
"github.com/steveyegge/beads/internal/storage/sqlite"
|
||||
"github.com/steveyegge/beads/internal/timeparsing"
|
||||
"github.com/steveyegge/beads/internal/types"
|
||||
"github.com/steveyegge/beads/internal/ui"
|
||||
"github.com/steveyegge/beads/internal/validation"
|
||||
@@ -142,6 +144,35 @@ var createCmd = &cobra.Command{
|
||||
FatalError("--event-category, --event-actor, --event-target, and --event-payload flags require --type=event")
|
||||
}
|
||||
|
||||
// Parse --due flag (GH#820)
|
||||
// Uses layered parsing: compact duration → NLP → date-only → RFC3339
|
||||
var dueAt *time.Time
|
||||
dueStr, _ := cmd.Flags().GetString("due")
|
||||
if dueStr != "" {
|
||||
t, err := timeparsing.ParseRelativeTime(dueStr, time.Now())
|
||||
if err != nil {
|
||||
FatalError("invalid --due format %q. Examples: +6h, tomorrow, next monday, 2025-01-15", dueStr)
|
||||
}
|
||||
dueAt = &t
|
||||
}
|
||||
|
||||
// Parse --defer flag (GH#820)
|
||||
var deferUntil *time.Time
|
||||
deferStr, _ := cmd.Flags().GetString("defer")
|
||||
if deferStr != "" {
|
||||
t, err := timeparsing.ParseRelativeTime(deferStr, time.Now())
|
||||
if err != nil {
|
||||
FatalError("invalid --defer format %q. Examples: +1h, tomorrow, next monday, 2025-01-15", deferStr)
|
||||
}
|
||||
// Warn if defer date is in the past (user probably meant future)
|
||||
if t.Before(time.Now()) && !silent && !debug.IsQuiet() {
|
||||
fmt.Fprintf(os.Stderr, "%s Defer date %q is in the past. Issue will appear in bd ready immediately.\n",
|
||||
ui.RenderWarn("!"), t.Format("2006-01-02 15:04"))
|
||||
fmt.Fprintf(os.Stderr, " Did you mean a future date? Use --defer=+1h or --defer=tomorrow\n")
|
||||
}
|
||||
deferUntil = &t
|
||||
}
|
||||
|
||||
// Handle --rig or --prefix flag: create issue in a different rig
|
||||
// Both flags use the same forgiving lookup (accepts rig names or prefixes)
|
||||
targetRig := rigOverride
|
||||
@@ -313,6 +344,8 @@ var createCmd = &cobra.Command{
|
||||
EventActor: eventActor,
|
||||
EventTarget: eventTarget,
|
||||
EventPayload: eventPayload,
|
||||
DueAt: dueStr,
|
||||
DeferUntil: deferStr,
|
||||
}
|
||||
|
||||
resp, err := daemonClient.Create(createArgs)
|
||||
@@ -370,6 +403,8 @@ var createCmd = &cobra.Command{
|
||||
Actor: eventActor,
|
||||
Target: eventTarget,
|
||||
Payload: eventPayload,
|
||||
DueAt: dueAt,
|
||||
DeferUntil: deferUntil,
|
||||
}
|
||||
|
||||
ctx := rootCtx
|
||||
@@ -580,6 +615,16 @@ func init() {
|
||||
createCmd.Flags().String("event-actor", "", "Entity URI who caused this event (requires --type=event)")
|
||||
createCmd.Flags().String("event-target", "", "Entity URI or bead ID affected (requires --type=event)")
|
||||
createCmd.Flags().String("event-payload", "", "Event-specific JSON data (requires --type=event)")
|
||||
// Time-based scheduling flags (GH#820)
|
||||
// Examples:
|
||||
// --due=+6h Due in 6 hours
|
||||
// --due=tomorrow Due tomorrow
|
||||
// --due="next monday" Due next Monday
|
||||
// --due=2025-01-15 Due on specific date
|
||||
// --defer=+1h Hidden from bd ready for 1 hour
|
||||
// --defer=tomorrow Hidden until tomorrow
|
||||
createCmd.Flags().String("due", "", "Due date/time. Formats: +6h, +1d, +2w, tomorrow, next monday, 2025-01-15")
|
||||
createCmd.Flags().String("defer", "", "Defer until date (issue hidden from bd ready until then). Same formats as --due")
|
||||
// Note: --json flag is defined as a persistent flag in main.go, not here
|
||||
rootCmd.AddCommand(createCmd)
|
||||
}
|
||||
|
||||
@@ -486,6 +486,103 @@ func TestCreateSuite(t *testing.T) {
|
||||
}
|
||||
})
|
||||
|
||||
// GH#820: Tests for DueAt and DeferUntil fields
|
||||
t.Run("WithDueAt", func(t *testing.T) {
|
||||
// Create issue with due date
|
||||
dueTime := time.Now().Add(24 * time.Hour) // Due in 24 hours
|
||||
issue := &types.Issue{
|
||||
Title: "Issue with due date",
|
||||
Priority: 1,
|
||||
Status: types.StatusOpen,
|
||||
IssueType: types.TypeTask,
|
||||
DueAt: &dueTime,
|
||||
CreatedAt: time.Now(),
|
||||
}
|
||||
|
||||
if err := s.CreateIssue(ctx, issue, "test"); err != nil {
|
||||
t.Fatalf("failed to create issue with due date: %v", err)
|
||||
}
|
||||
|
||||
// Retrieve and verify
|
||||
retrieved, err := s.GetIssue(ctx, issue.ID)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to get issue: %v", err)
|
||||
}
|
||||
|
||||
if retrieved.DueAt == nil {
|
||||
t.Fatal("expected DueAt to be set")
|
||||
}
|
||||
// Compare with 1-second tolerance for database round-trip
|
||||
diff := retrieved.DueAt.Sub(dueTime)
|
||||
if diff < -time.Second || diff > time.Second {
|
||||
t.Errorf("DueAt mismatch: got %v, want %v", retrieved.DueAt, dueTime)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("WithDeferUntil", func(t *testing.T) {
|
||||
// Create issue with defer_until
|
||||
deferTime := time.Now().Add(2 * time.Hour) // Defer for 2 hours
|
||||
issue := &types.Issue{
|
||||
Title: "Issue with defer",
|
||||
Priority: 1,
|
||||
Status: types.StatusOpen,
|
||||
IssueType: types.TypeTask,
|
||||
DeferUntil: &deferTime,
|
||||
CreatedAt: time.Now(),
|
||||
}
|
||||
|
||||
if err := s.CreateIssue(ctx, issue, "test"); err != nil {
|
||||
t.Fatalf("failed to create issue with defer: %v", err)
|
||||
}
|
||||
|
||||
// Retrieve and verify
|
||||
retrieved, err := s.GetIssue(ctx, issue.ID)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to get issue: %v", err)
|
||||
}
|
||||
|
||||
if retrieved.DeferUntil == nil {
|
||||
t.Fatal("expected DeferUntil to be set")
|
||||
}
|
||||
// Compare with 1-second tolerance for database round-trip
|
||||
diff := retrieved.DeferUntil.Sub(deferTime)
|
||||
if diff < -time.Second || diff > time.Second {
|
||||
t.Errorf("DeferUntil mismatch: got %v, want %v", retrieved.DeferUntil, deferTime)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("WithBothDueAndDefer", func(t *testing.T) {
|
||||
// Create issue with both due and defer
|
||||
dueTime := time.Now().Add(48 * time.Hour) // Due in 48 hours
|
||||
deferTime := time.Now().Add(24 * time.Hour) // Defer for 24 hours
|
||||
issue := &types.Issue{
|
||||
Title: "Issue with both due and defer",
|
||||
Priority: 1,
|
||||
Status: types.StatusOpen,
|
||||
IssueType: types.TypeTask,
|
||||
DueAt: &dueTime,
|
||||
DeferUntil: &deferTime,
|
||||
CreatedAt: time.Now(),
|
||||
}
|
||||
|
||||
if err := s.CreateIssue(ctx, issue, "test"); err != nil {
|
||||
t.Fatalf("failed to create issue: %v", err)
|
||||
}
|
||||
|
||||
// Retrieve and verify both fields
|
||||
retrieved, err := s.GetIssue(ctx, issue.ID)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to get issue: %v", err)
|
||||
}
|
||||
|
||||
if retrieved.DueAt == nil {
|
||||
t.Fatal("expected DueAt to be set")
|
||||
}
|
||||
if retrieved.DeferUntil == nil {
|
||||
t.Fatal("expected DeferUntil to be set")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("DiscoveredFromInheritsSourceRepo", func(t *testing.T) {
|
||||
// Create a parent issue with a custom source_repo
|
||||
parent := &types.Issue{
|
||||
|
||||
@@ -4,9 +4,11 @@ import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"os"
|
||||
"time"
|
||||
|
||||
"github.com/spf13/cobra"
|
||||
"github.com/steveyegge/beads/internal/rpc"
|
||||
"github.com/steveyegge/beads/internal/timeparsing"
|
||||
"github.com/steveyegge/beads/internal/types"
|
||||
"github.com/steveyegge/beads/internal/ui"
|
||||
"github.com/steveyegge/beads/internal/utils"
|
||||
@@ -25,12 +27,25 @@ be revisited.
|
||||
Deferred issues don't show in 'bd ready' but remain visible in 'bd list'.
|
||||
|
||||
Examples:
|
||||
bd defer bd-abc # Defer a single issue
|
||||
bd defer bd-abc bd-def # Defer multiple issues`,
|
||||
bd defer bd-abc # Defer a single issue (status-based)
|
||||
bd defer bd-abc --until=tomorrow # Defer until specific time
|
||||
bd defer bd-abc bd-def # Defer multiple issues`,
|
||||
Args: cobra.MinimumNArgs(1),
|
||||
Run: func(cmd *cobra.Command, args []string) {
|
||||
CheckReadonly("defer")
|
||||
|
||||
// Parse --until flag (GH#820)
|
||||
var deferUntil *time.Time
|
||||
untilStr, _ := cmd.Flags().GetString("until")
|
||||
if untilStr != "" {
|
||||
t, err := timeparsing.ParseRelativeTime(untilStr, time.Now())
|
||||
if err != nil {
|
||||
fmt.Fprintf(os.Stderr, "Error: invalid --until format %q. Examples: +1h, tomorrow, next monday, 2025-01-15\n", untilStr)
|
||||
os.Exit(1)
|
||||
}
|
||||
deferUntil = &t
|
||||
}
|
||||
|
||||
ctx := rootCtx
|
||||
|
||||
// Resolve partial IDs first
|
||||
@@ -69,6 +84,11 @@ Examples:
|
||||
ID: id,
|
||||
Status: &status,
|
||||
}
|
||||
// Add defer_until if --until specified (GH#820)
|
||||
if deferUntil != nil {
|
||||
s := deferUntil.Format(time.RFC3339)
|
||||
updateArgs.DeferUntil = &s
|
||||
}
|
||||
|
||||
resp, err := daemonClient.Update(updateArgs)
|
||||
if err != nil {
|
||||
@@ -108,6 +128,10 @@ Examples:
|
||||
updates := map[string]interface{}{
|
||||
"status": string(types.StatusDeferred),
|
||||
}
|
||||
// Add defer_until if --until specified (GH#820)
|
||||
if deferUntil != nil {
|
||||
updates["defer_until"] = *deferUntil
|
||||
}
|
||||
|
||||
if err := store.UpdateIssue(ctx, fullID, updates, actor); err != nil {
|
||||
fmt.Fprintf(os.Stderr, "Error deferring %s: %v\n", fullID, err)
|
||||
@@ -136,5 +160,7 @@ Examples:
|
||||
}
|
||||
|
||||
func init() {
|
||||
// Time-based scheduling flag (GH#820)
|
||||
deferCmd.Flags().String("until", "", "Defer until specific time (e.g., +1h, tomorrow, next monday)")
|
||||
rootCmd.AddCommand(deferCmd)
|
||||
}
|
||||
|
||||
@@ -20,28 +20,18 @@ import (
|
||||
"github.com/steveyegge/beads/internal/config"
|
||||
"github.com/steveyegge/beads/internal/rpc"
|
||||
"github.com/steveyegge/beads/internal/storage"
|
||||
"github.com/steveyegge/beads/internal/timeparsing"
|
||||
"github.com/steveyegge/beads/internal/types"
|
||||
"github.com/steveyegge/beads/internal/ui"
|
||||
"github.com/steveyegge/beads/internal/util"
|
||||
"github.com/steveyegge/beads/internal/validation"
|
||||
)
|
||||
|
||||
// parseTimeFlag parses time strings in multiple formats
|
||||
// parseTimeFlag parses time strings using the layered time parsing architecture.
|
||||
// Supports compact durations (+6h, -1d), natural language (tomorrow, next monday),
|
||||
// and absolute formats (2006-01-02, RFC3339).
|
||||
func parseTimeFlag(s string) (time.Time, error) {
|
||||
formats := []string{
|
||||
time.RFC3339,
|
||||
"2006-01-02",
|
||||
"2006-01-02T15:04:05",
|
||||
"2006-01-02 15:04:05",
|
||||
}
|
||||
|
||||
for _, format := range formats {
|
||||
if t, err := time.Parse(format, s); err == nil {
|
||||
return t, nil
|
||||
}
|
||||
}
|
||||
|
||||
return time.Time{}, fmt.Errorf("unable to parse time %q (try formats: 2006-01-02, 2006-01-02T15:04:05, or RFC3339)", s)
|
||||
return timeparsing.ParseRelativeTime(s, time.Now())
|
||||
}
|
||||
|
||||
// pinIndicator returns a pushpin emoji prefix for pinned issues
|
||||
@@ -434,6 +424,14 @@ var listCmd = &cobra.Command{
|
||||
molType = &mt
|
||||
}
|
||||
|
||||
// Time-based scheduling filters (GH#820)
|
||||
deferredFlag, _ := cmd.Flags().GetBool("deferred")
|
||||
deferAfter, _ := cmd.Flags().GetString("defer-after")
|
||||
deferBefore, _ := cmd.Flags().GetString("defer-before")
|
||||
dueAfter, _ := cmd.Flags().GetString("due-after")
|
||||
dueBefore, _ := cmd.Flags().GetString("due-before")
|
||||
overdueFlag, _ := cmd.Flags().GetBool("overdue")
|
||||
|
||||
// Pretty and watch flags (GH#654)
|
||||
prettyFormat, _ := cmd.Flags().GetBool("pretty")
|
||||
watchMode, _ := cmd.Flags().GetBool("watch")
|
||||
@@ -640,6 +638,46 @@ var listCmd = &cobra.Command{
|
||||
filter.MolType = molType
|
||||
}
|
||||
|
||||
// Time-based scheduling filters (GH#820)
|
||||
if deferredFlag {
|
||||
filter.Deferred = true
|
||||
}
|
||||
if deferAfter != "" {
|
||||
t, err := parseTimeFlag(deferAfter)
|
||||
if err != nil {
|
||||
fmt.Fprintf(os.Stderr, "Error parsing --defer-after: %v\n", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
filter.DeferAfter = &t
|
||||
}
|
||||
if deferBefore != "" {
|
||||
t, err := parseTimeFlag(deferBefore)
|
||||
if err != nil {
|
||||
fmt.Fprintf(os.Stderr, "Error parsing --defer-before: %v\n", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
filter.DeferBefore = &t
|
||||
}
|
||||
if dueAfter != "" {
|
||||
t, err := parseTimeFlag(dueAfter)
|
||||
if err != nil {
|
||||
fmt.Fprintf(os.Stderr, "Error parsing --due-after: %v\n", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
filter.DueAfter = &t
|
||||
}
|
||||
if dueBefore != "" {
|
||||
t, err := parseTimeFlag(dueBefore)
|
||||
if err != nil {
|
||||
fmt.Fprintf(os.Stderr, "Error parsing --due-before: %v\n", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
filter.DueBefore = &t
|
||||
}
|
||||
if overdueFlag {
|
||||
filter.Overdue = true
|
||||
}
|
||||
|
||||
// Check database freshness before reading
|
||||
// Skip check when using daemon (daemon auto-imports on staleness)
|
||||
ctx := rootCtx
|
||||
@@ -738,6 +776,22 @@ var listCmd = &cobra.Command{
|
||||
}
|
||||
}
|
||||
|
||||
// Time-based scheduling filters (GH#820)
|
||||
listArgs.Deferred = filter.Deferred
|
||||
if filter.DeferAfter != nil {
|
||||
listArgs.DeferAfter = filter.DeferAfter.Format(time.RFC3339)
|
||||
}
|
||||
if filter.DeferBefore != nil {
|
||||
listArgs.DeferBefore = filter.DeferBefore.Format(time.RFC3339)
|
||||
}
|
||||
if filter.DueAfter != nil {
|
||||
listArgs.DueAfter = filter.DueAfter.Format(time.RFC3339)
|
||||
}
|
||||
if filter.DueBefore != nil {
|
||||
listArgs.DueBefore = filter.DueBefore.Format(time.RFC3339)
|
||||
}
|
||||
listArgs.Overdue = filter.Overdue
|
||||
|
||||
resp, err := daemonClient.List(listArgs)
|
||||
if err != nil {
|
||||
fmt.Fprintf(os.Stderr, "Error: %v\n", err)
|
||||
@@ -987,6 +1041,14 @@ func init() {
|
||||
// Molecule type filtering
|
||||
listCmd.Flags().String("mol-type", "", "Filter by molecule type: swarm, patrol, or work")
|
||||
|
||||
// Time-based scheduling filters (GH#820)
|
||||
listCmd.Flags().Bool("deferred", false, "Show only issues with defer_until set")
|
||||
listCmd.Flags().String("defer-after", "", "Filter issues deferred after date (supports relative: +6h, tomorrow)")
|
||||
listCmd.Flags().String("defer-before", "", "Filter issues deferred before date (supports relative: +6h, tomorrow)")
|
||||
listCmd.Flags().String("due-after", "", "Filter issues due after date (supports relative: +6h, tomorrow)")
|
||||
listCmd.Flags().String("due-before", "", "Filter issues due before date (supports relative: +6h, tomorrow)")
|
||||
listCmd.Flags().Bool("overdue", false, "Show only issues with due_at in the past (not closed)")
|
||||
|
||||
// Pretty and watch flags (GH#654)
|
||||
listCmd.Flags().Bool("pretty", false, "Display issues in a tree format with status/priority symbols")
|
||||
listCmd.Flags().BoolP("watch", "w", false, "Watch for changes and auto-update display (implies --pretty)")
|
||||
|
||||
@@ -602,16 +602,24 @@ func TestParseTimeFlag(t *testing.T) {
|
||||
input string
|
||||
wantErr bool
|
||||
}{
|
||||
// Absolute formats
|
||||
{"RFC3339", "2023-01-15T10:30:00Z", false},
|
||||
{"Date only", "2023-01-15", false},
|
||||
{"DateTime without zone", "2023-01-15T10:30:00", false},
|
||||
{"DateTime with space", "2023-01-15 10:30:00", false},
|
||||
{"Invalid format", "January 15, 2023", true},
|
||||
// Compact duration formats (GH#820)
|
||||
{"Compact hours", "+6h", false},
|
||||
{"Compact days", "+1d", false},
|
||||
{"Compact weeks", "+2w", false},
|
||||
{"Compact negative", "-3d", false},
|
||||
// Natural language (GH#820)
|
||||
{"Natural tomorrow", "tomorrow", false},
|
||||
{"Natural next monday", "next monday", false},
|
||||
// Invalid formats
|
||||
{"Invalid format", "not-a-date", true},
|
||||
{"Empty string", "", true},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
_, err := parseTimeFlag(tt.input)
|
||||
if (err != nil) != tt.wantErr {
|
||||
t.Errorf("parseTimeFlag(%q) error = %v, wantErr %v", tt.input, err, tt.wantErr)
|
||||
@@ -619,3 +627,177 @@ func TestParseTimeFlag(t *testing.T) {
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestListTimeBasedFilters tests the time-based scheduling filters (GH#820)
|
||||
func TestListTimeBasedFilters(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
testDB := filepath.Join(tmpDir, ".beads", "beads.db")
|
||||
s := newTestStore(t, testDB)
|
||||
ctx := context.Background()
|
||||
|
||||
now := time.Now()
|
||||
yesterday := now.Add(-24 * time.Hour)
|
||||
tomorrow := now.Add(24 * time.Hour)
|
||||
nextWeek := now.Add(7 * 24 * time.Hour)
|
||||
|
||||
// Create test issues with varied due_at and defer_until values
|
||||
issueNoSchedule := &types.Issue{
|
||||
Title: "Issue without scheduling",
|
||||
Priority: 2,
|
||||
IssueType: types.TypeTask,
|
||||
Status: types.StatusOpen,
|
||||
}
|
||||
issueDeferredFuture := &types.Issue{
|
||||
Title: "Deferred until tomorrow",
|
||||
Priority: 2,
|
||||
IssueType: types.TypeTask,
|
||||
Status: types.StatusOpen,
|
||||
DeferUntil: &tomorrow,
|
||||
}
|
||||
issueDeferredPast := &types.Issue{
|
||||
Title: "Was deferred until yesterday",
|
||||
Priority: 2,
|
||||
IssueType: types.TypeTask,
|
||||
Status: types.StatusOpen,
|
||||
DeferUntil: &yesterday,
|
||||
}
|
||||
issueDueNextWeek := &types.Issue{
|
||||
Title: "Due next week",
|
||||
Priority: 1,
|
||||
IssueType: types.TypeTask,
|
||||
Status: types.StatusOpen,
|
||||
DueAt: &nextWeek,
|
||||
}
|
||||
issueOverdue := &types.Issue{
|
||||
Title: "Overdue issue",
|
||||
Priority: 0,
|
||||
IssueType: types.TypeBug,
|
||||
Status: types.StatusOpen,
|
||||
DueAt: &yesterday,
|
||||
}
|
||||
issueOverdueClosed := &types.Issue{
|
||||
Title: "Overdue but closed",
|
||||
Priority: 0,
|
||||
IssueType: types.TypeBug,
|
||||
Status: types.StatusClosed,
|
||||
DueAt: &yesterday,
|
||||
ClosedAt: &now,
|
||||
}
|
||||
|
||||
for _, issue := range []*types.Issue{
|
||||
issueNoSchedule, issueDeferredFuture, issueDeferredPast,
|
||||
issueDueNextWeek, issueOverdue, issueOverdueClosed,
|
||||
} {
|
||||
if err := s.CreateIssue(ctx, issue, "test-user"); err != nil {
|
||||
t.Fatalf("Failed to create issue: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
t.Run("filter by deferred flag", func(t *testing.T) {
|
||||
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
|
||||
Deferred: true,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("Search failed: %v", err)
|
||||
}
|
||||
// Should find issues with defer_until set (future and past)
|
||||
if len(results) != 2 {
|
||||
t.Errorf("Expected 2 deferred issues, got %d", len(results))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("filter by defer-after", func(t *testing.T) {
|
||||
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
|
||||
DeferAfter: &now,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("Search failed: %v", err)
|
||||
}
|
||||
// Should find issues deferred after now (tomorrow)
|
||||
if len(results) != 1 {
|
||||
t.Errorf("Expected 1 issue deferred after now, got %d", len(results))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("filter by defer-before", func(t *testing.T) {
|
||||
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
|
||||
DeferBefore: &now,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("Search failed: %v", err)
|
||||
}
|
||||
// Should find issues deferred before now (yesterday)
|
||||
if len(results) != 1 {
|
||||
t.Errorf("Expected 1 issue deferred before now, got %d", len(results))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("filter by due-after", func(t *testing.T) {
|
||||
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
|
||||
DueAfter: &now,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("Search failed: %v", err)
|
||||
}
|
||||
// Should find issues due after now (next week)
|
||||
if len(results) != 1 {
|
||||
t.Errorf("Expected 1 issue due after now, got %d", len(results))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("filter by due-before", func(t *testing.T) {
|
||||
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
|
||||
DueBefore: &now,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("Search failed: %v", err)
|
||||
}
|
||||
// Should find issues due before now (overdue open + closed = 2)
|
||||
if len(results) != 2 {
|
||||
t.Errorf("Expected 2 issues due before now, got %d", len(results))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("filter by overdue", func(t *testing.T) {
|
||||
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
|
||||
Overdue: true,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("Search failed: %v", err)
|
||||
}
|
||||
// Should find only the open overdue issue (not the closed one)
|
||||
if len(results) != 1 {
|
||||
t.Errorf("Expected 1 overdue issue, got %d", len(results))
|
||||
}
|
||||
if len(results) > 0 && results[0].ID != issueOverdue.ID {
|
||||
t.Errorf("Expected issue %s, got %s", issueOverdue.ID, results[0].ID)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("combined filters defer and due", func(t *testing.T) {
|
||||
// Issue with both defer_until and due_at
|
||||
bothSet := &types.Issue{
|
||||
Title: "Both deferred and due",
|
||||
Priority: 1,
|
||||
IssueType: types.TypeTask,
|
||||
Status: types.StatusOpen,
|
||||
DeferUntil: &tomorrow,
|
||||
DueAt: &nextWeek,
|
||||
}
|
||||
if err := s.CreateIssue(ctx, bothSet, "test-user"); err != nil {
|
||||
t.Fatalf("Failed to create issue: %v", err)
|
||||
}
|
||||
|
||||
results, err := s.SearchIssues(ctx, "", types.IssueFilter{
|
||||
Deferred: true,
|
||||
DueAfter: &now,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("Search failed: %v", err)
|
||||
}
|
||||
// Should find the issue with both defer_until set and due_at > now
|
||||
if len(results) != 1 {
|
||||
t.Errorf("Expected 1 issue with both filters, got %d", len(results))
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
@@ -43,6 +43,7 @@ This is useful for agents executing molecules to see which steps can run next.`,
|
||||
parentID, _ := cmd.Flags().GetString("parent")
|
||||
molTypeStr, _ := cmd.Flags().GetString("mol-type")
|
||||
prettyFormat, _ := cmd.Flags().GetBool("pretty")
|
||||
includeDeferred, _ := cmd.Flags().GetBool("include-deferred")
|
||||
var molType *types.MolType
|
||||
if molTypeStr != "" {
|
||||
mt := types.MolType(molTypeStr)
|
||||
@@ -67,12 +68,13 @@ This is useful for agents executing molecules to see which steps can run next.`,
|
||||
|
||||
filter := types.WorkFilter{
|
||||
// Leave Status empty to get both 'open' and 'in_progress'
|
||||
Type: issueType,
|
||||
Limit: limit,
|
||||
Unassigned: unassigned,
|
||||
SortPolicy: types.SortPolicy(sortPolicy),
|
||||
Labels: labels,
|
||||
LabelsAny: labelsAny,
|
||||
Type: issueType,
|
||||
Limit: limit,
|
||||
Unassigned: unassigned,
|
||||
SortPolicy: types.SortPolicy(sortPolicy),
|
||||
Labels: labels,
|
||||
LabelsAny: labelsAny,
|
||||
IncludeDeferred: includeDeferred, // GH#820: respect --include-deferred flag
|
||||
}
|
||||
// Use Changed() to properly handle P0 (priority=0)
|
||||
if cmd.Flags().Changed("priority") {
|
||||
@@ -96,15 +98,16 @@ This is useful for agents executing molecules to see which steps can run next.`,
|
||||
// If daemon is running, use RPC
|
||||
if daemonClient != nil {
|
||||
readyArgs := &rpc.ReadyArgs{
|
||||
Assignee: assignee,
|
||||
Unassigned: unassigned,
|
||||
Type: issueType,
|
||||
Limit: limit,
|
||||
SortPolicy: sortPolicy,
|
||||
Labels: labels,
|
||||
LabelsAny: labelsAny,
|
||||
ParentID: parentID,
|
||||
MolType: molTypeStr,
|
||||
Assignee: assignee,
|
||||
Unassigned: unassigned,
|
||||
Type: issueType,
|
||||
Limit: limit,
|
||||
SortPolicy: sortPolicy,
|
||||
Labels: labels,
|
||||
LabelsAny: labelsAny,
|
||||
ParentID: parentID,
|
||||
MolType: molTypeStr,
|
||||
IncludeDeferred: includeDeferred, // GH#820
|
||||
}
|
||||
if cmd.Flags().Changed("priority") {
|
||||
priority, _ := cmd.Flags().GetInt("priority")
|
||||
@@ -447,6 +450,7 @@ func init() {
|
||||
readyCmd.Flags().String("parent", "", "Filter to descendants of this bead/epic")
|
||||
readyCmd.Flags().String("mol-type", "", "Filter by molecule type: swarm, patrol, or work")
|
||||
readyCmd.Flags().Bool("pretty", false, "Display issues in a tree format with status/priority symbols")
|
||||
readyCmd.Flags().Bool("include-deferred", false, "Include issues with future defer_until timestamps")
|
||||
rootCmd.AddCommand(readyCmd)
|
||||
blockedCmd.Flags().String("parent", "", "Filter to descendants of this bead/epic")
|
||||
rootCmd.AddCommand(blockedCmd)
|
||||
|
||||
@@ -261,6 +261,110 @@ func TestReadyCommandInit(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
// GH#820: Tests for defer_until filtering in ready work
|
||||
func TestReadyWorkDeferUntil(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
testDB := filepath.Join(tmpDir, ".beads", "beads.db")
|
||||
s := newTestStore(t, testDB)
|
||||
ctx := context.Background()
|
||||
|
||||
// Create issues with different defer_until values
|
||||
futureDefer := time.Now().Add(24 * time.Hour) // Deferred to future
|
||||
pastDefer := time.Now().Add(-1 * time.Hour) // Deferred to past (should be visible)
|
||||
|
||||
issues := []*types.Issue{
|
||||
{
|
||||
ID: "test-future-defer",
|
||||
Title: "Future deferred task",
|
||||
Status: types.StatusOpen,
|
||||
Priority: 1,
|
||||
IssueType: types.TypeTask,
|
||||
DeferUntil: &futureDefer,
|
||||
CreatedAt: time.Now(),
|
||||
},
|
||||
{
|
||||
ID: "test-past-defer",
|
||||
Title: "Past deferred task",
|
||||
Status: types.StatusOpen,
|
||||
Priority: 1,
|
||||
IssueType: types.TypeTask,
|
||||
DeferUntil: &pastDefer,
|
||||
CreatedAt: time.Now(),
|
||||
},
|
||||
{
|
||||
ID: "test-no-defer",
|
||||
Title: "Normal task (no defer)",
|
||||
Status: types.StatusOpen,
|
||||
Priority: 1,
|
||||
IssueType: types.TypeTask,
|
||||
CreatedAt: time.Now(),
|
||||
},
|
||||
}
|
||||
|
||||
for _, issue := range issues {
|
||||
if err := s.CreateIssue(ctx, issue, "test"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
t.Run("ExcludesFutureDeferredByDefault", func(t *testing.T) {
|
||||
// Default behavior: exclude issues with future defer_until
|
||||
ready, err := s.GetReadyWork(ctx, types.WorkFilter{})
|
||||
if err != nil {
|
||||
t.Fatalf("GetReadyWork failed: %v", err)
|
||||
}
|
||||
|
||||
// Should NOT include test-future-defer
|
||||
for _, issue := range ready {
|
||||
if issue.ID == "test-future-defer" {
|
||||
t.Error("Future deferred issue should not appear in ready work by default")
|
||||
}
|
||||
}
|
||||
|
||||
// Should include test-past-defer and test-no-defer
|
||||
foundPast := false
|
||||
foundNoDefer := false
|
||||
for _, issue := range ready {
|
||||
if issue.ID == "test-past-defer" {
|
||||
foundPast = true
|
||||
}
|
||||
if issue.ID == "test-no-defer" {
|
||||
foundNoDefer = true
|
||||
}
|
||||
}
|
||||
|
||||
if !foundPast {
|
||||
t.Error("Past deferred issue should appear in ready work")
|
||||
}
|
||||
if !foundNoDefer {
|
||||
t.Error("Issue without defer should appear in ready work")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("IncludeDeferredShowsAll", func(t *testing.T) {
|
||||
// With IncludeDeferred: show all issues including future deferred
|
||||
ready, err := s.GetReadyWork(ctx, types.WorkFilter{
|
||||
IncludeDeferred: true,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("GetReadyWork with IncludeDeferred failed: %v", err)
|
||||
}
|
||||
|
||||
// Should include test-future-defer
|
||||
foundFuture := false
|
||||
for _, issue := range ready {
|
||||
if issue.ID == "test-future-defer" {
|
||||
foundFuture = true
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
if !foundFuture {
|
||||
t.Error("Future deferred issue should appear when IncludeDeferred=true")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestReadyWorkUnassigned(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
testDB := filepath.Join(tmpDir, ".beads", "beads.db")
|
||||
|
||||
@@ -225,6 +225,12 @@ var showCmd = &cobra.Command{
|
||||
fmt.Printf("Created by: %s\n", issue.CreatedBy)
|
||||
}
|
||||
fmt.Printf("Updated: %s\n", issue.UpdatedAt.Format("2006-01-02 15:04"))
|
||||
if issue.DueAt != nil {
|
||||
fmt.Printf("Due: %s\n", issue.DueAt.Format("2006-01-02 15:04"))
|
||||
}
|
||||
if issue.DeferUntil != nil {
|
||||
fmt.Printf("Deferred until: %s\n", issue.DeferUntil.Format("2006-01-02 15:04"))
|
||||
}
|
||||
|
||||
// Show compaction status
|
||||
if issue.CompactionLevel > 0 {
|
||||
@@ -445,6 +451,12 @@ var showCmd = &cobra.Command{
|
||||
fmt.Printf("Created by: %s\n", issue.CreatedBy)
|
||||
}
|
||||
fmt.Printf("Updated: %s\n", issue.UpdatedAt.Format("2006-01-02 15:04"))
|
||||
if issue.DueAt != nil {
|
||||
fmt.Printf("Due: %s\n", issue.DueAt.Format("2006-01-02 15:04"))
|
||||
}
|
||||
if issue.DeferUntil != nil {
|
||||
fmt.Printf("Deferred until: %s\n", issue.DeferUntil.Format("2006-01-02 15:04"))
|
||||
}
|
||||
|
||||
// Show compaction status footer
|
||||
if issue.CompactionLevel > 0 {
|
||||
|
||||
@@ -61,9 +61,11 @@ Examples:
|
||||
if daemonClient != nil {
|
||||
for _, id := range resolvedIDs {
|
||||
status := string(types.StatusOpen)
|
||||
emptyStr := "" // Clear defer_until by sending empty string (GH#820)
|
||||
updateArgs := &rpc.UpdateArgs{
|
||||
ID: id,
|
||||
Status: &status,
|
||||
ID: id,
|
||||
Status: &status,
|
||||
DeferUntil: &emptyStr, // Clear defer_until timestamp
|
||||
}
|
||||
|
||||
resp, err := daemonClient.Update(updateArgs)
|
||||
@@ -102,7 +104,8 @@ Examples:
|
||||
}
|
||||
|
||||
updates := map[string]interface{}{
|
||||
"status": string(types.StatusOpen),
|
||||
"status": string(types.StatusOpen),
|
||||
"defer_until": nil, // Clear defer_until timestamp (GH#820)
|
||||
}
|
||||
|
||||
if err := store.UpdateIssue(ctx, fullID, updates, actor); err != nil {
|
||||
|
||||
@@ -4,10 +4,12 @@ import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"os"
|
||||
"time"
|
||||
|
||||
"github.com/spf13/cobra"
|
||||
"github.com/steveyegge/beads/internal/hooks"
|
||||
"github.com/steveyegge/beads/internal/rpc"
|
||||
"github.com/steveyegge/beads/internal/timeparsing"
|
||||
"github.com/steveyegge/beads/internal/types"
|
||||
"github.com/steveyegge/beads/internal/ui"
|
||||
"github.com/steveyegge/beads/internal/utils"
|
||||
@@ -132,6 +134,39 @@ create, update, show, or close operation).`,
|
||||
}
|
||||
updates["issue_type"] = issueType
|
||||
}
|
||||
// Time-based scheduling flags (GH#820)
|
||||
if cmd.Flags().Changed("due") {
|
||||
dueStr, _ := cmd.Flags().GetString("due")
|
||||
if dueStr == "" {
|
||||
// Empty string clears the due date
|
||||
updates["due_at"] = nil
|
||||
} else {
|
||||
t, err := timeparsing.ParseRelativeTime(dueStr, time.Now())
|
||||
if err != nil {
|
||||
FatalErrorRespectJSON("invalid --due format %q. Examples: +6h, tomorrow, next monday, 2025-01-15", dueStr)
|
||||
}
|
||||
updates["due_at"] = t
|
||||
}
|
||||
}
|
||||
if cmd.Flags().Changed("defer") {
|
||||
deferStr, _ := cmd.Flags().GetString("defer")
|
||||
if deferStr == "" {
|
||||
// Empty string clears the defer_until
|
||||
updates["defer_until"] = nil
|
||||
} else {
|
||||
t, err := timeparsing.ParseRelativeTime(deferStr, time.Now())
|
||||
if err != nil {
|
||||
FatalErrorRespectJSON("invalid --defer format %q. Examples: +1h, tomorrow, next monday, 2025-01-15", deferStr)
|
||||
}
|
||||
// Warn if defer date is in the past (user probably meant future)
|
||||
if t.Before(time.Now()) && !jsonOutput {
|
||||
fmt.Fprintf(os.Stderr, "%s Defer date %q is in the past. Issue will appear in bd ready immediately.\n",
|
||||
ui.RenderWarn("!"), t.Format("2006-01-02 15:04"))
|
||||
fmt.Fprintf(os.Stderr, " Did you mean a future date? Use --defer=+1h or --defer=tomorrow\n")
|
||||
}
|
||||
updates["defer_until"] = t
|
||||
}
|
||||
}
|
||||
|
||||
// Get claim flag
|
||||
claimFlag, _ := cmd.Flags().GetBool("claim")
|
||||
@@ -229,6 +264,23 @@ create, update, show, or close operation).`,
|
||||
if parent, ok := updates["parent"].(string); ok {
|
||||
updateArgs.Parent = &parent
|
||||
}
|
||||
// Time-based scheduling (GH#820)
|
||||
if dueAt, ok := updates["due_at"].(time.Time); ok {
|
||||
s := dueAt.Format(time.RFC3339)
|
||||
updateArgs.DueAt = &s
|
||||
} else if updates["due_at"] == nil && cmd.Flags().Changed("due") {
|
||||
// Explicit clear
|
||||
empty := ""
|
||||
updateArgs.DueAt = &empty
|
||||
}
|
||||
if deferUntil, ok := updates["defer_until"].(time.Time); ok {
|
||||
s := deferUntil.Format(time.RFC3339)
|
||||
updateArgs.DeferUntil = &s
|
||||
} else if updates["defer_until"] == nil && cmd.Flags().Changed("defer") {
|
||||
// Explicit clear
|
||||
empty := ""
|
||||
updateArgs.DeferUntil = &empty
|
||||
}
|
||||
|
||||
// Set claim flag for atomic claim operation
|
||||
updateArgs.Claim = claimFlag
|
||||
@@ -528,5 +580,16 @@ func init() {
|
||||
updateCmd.Flags().String("parent", "", "New parent issue ID (reparents the issue, use empty string to remove parent)")
|
||||
updateCmd.Flags().Bool("claim", false, "Atomically claim the issue (sets assignee to you, status to in_progress; fails if already claimed)")
|
||||
updateCmd.Flags().String("session", "", "Claude Code session ID for status=closed (or set CLAUDE_SESSION_ID env var)")
|
||||
// Time-based scheduling flags (GH#820)
|
||||
// Examples:
|
||||
// --due=+6h Due in 6 hours
|
||||
// --due=tomorrow Due tomorrow
|
||||
// --due="next monday" Due next Monday
|
||||
// --due=2025-01-15 Due on specific date
|
||||
// --due="" Clear due date
|
||||
// --defer=+1h Hidden from bd ready for 1 hour
|
||||
// --defer="" Clear defer (show in bd ready immediately)
|
||||
updateCmd.Flags().String("due", "", "Due date/time (empty to clear). Formats: +6h, +1d, +2w, tomorrow, next monday, 2025-01-15")
|
||||
updateCmd.Flags().String("defer", "", "Defer until date (empty to clear). Issue hidden from bd ready until then")
|
||||
rootCmd.AddCommand(updateCmd)
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user