summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--internal/askcli/command_delete.go12
-rw-r--r--internal/askcli/command_delete_test.go48
-rw-r--r--internal/askcli/command_dep.go40
-rw-r--r--internal/askcli/command_dep_test.go70
-rw-r--r--internal/askcli/command_info_add.go7
-rw-r--r--internal/askcli/command_info_add_test.go38
-rw-r--r--internal/askcli/command_write.go96
-rw-r--r--internal/askcli/command_write_test.go80
-rw-r--r--internal/askcli/task_alias_cache.go24
-rw-r--r--internal/askcli/task_selector.go119
-rw-r--r--internal/askcli/task_selector_test.go157
11 files changed, 606 insertions, 85 deletions
diff --git a/internal/askcli/command_delete.go b/internal/askcli/command_delete.go
index 45f0f3d..64bcdfc 100644
--- a/internal/askcli/command_delete.go
+++ b/internal/askcli/command_delete.go
@@ -11,16 +11,16 @@ func (d Dispatcher) handleDelete(ctx context.Context, args []string, stdin io.Re
io.WriteString(stderr, "error: ask delete requires a UUID argument\n")
return 1, nil
}
- uuid := NormalizeUUID(args[1])
- if IsNumericID(uuid) {
- io.WriteString(stderr, RejectNumericID())
- return 1, nil
+ resolved, _, code, err := d.resolveTaskSelector(ctx, args[1], stderr)
+ if err != nil {
+ writeInfoError(stderr, err)
+ return code, nil
}
var outBuf bytes.Buffer
- code, err := d.runner.Run(ctx, []string{"uuid:" + uuid, "delete"}, stdin, &outBuf, io.Discard)
+ code, err = d.runner.Run(ctx, []string{"uuid:" + resolved.UUID, "delete"}, stdin, &outBuf, io.Discard)
if code != 0 {
return code, err
}
- io.WriteString(stdout, FormatSuccess(uuid))
+ io.WriteString(stdout, FormatSuccess(resolved.UUID))
return 0, nil
}
diff --git a/internal/askcli/command_delete_test.go b/internal/askcli/command_delete_test.go
index 9cd2e94..ff3f435 100644
--- a/internal/askcli/command_delete_test.go
+++ b/internal/askcli/command_delete_test.go
@@ -4,12 +4,18 @@ import (
"bytes"
"context"
"io"
+ "path/filepath"
"strings"
"testing"
+ "time"
)
func TestHandleDelete_Success(t *testing.T) {
d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ if len(args) == 2 && args[0] == "uuid:test-uuid-123" && args[1] == "export" {
+ io.WriteString(stdout, `[{"uuid":"test-uuid-123","description":"Task","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+ return 0, nil
+ }
return 0, nil
}})
var stdout, stderr bytes.Buffer
@@ -81,6 +87,10 @@ func TestHandleDelete_CommandFails(t *testing.T) {
func TestHandleDelete_PassesCorrectArgs(t *testing.T) {
var capturedArgs []string
d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ if len(args) == 2 && args[1] == "export" {
+ io.WriteString(stdout, `[{"uuid":"my-uuid","description":"Task","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+ return 0, nil
+ }
capturedArgs = args
return 0, nil
}})
@@ -90,3 +100,41 @@ func TestHandleDelete_PassesCorrectArgs(t *testing.T) {
t.Fatalf("capturedArgs = %v, want [uuid:my-uuid, delete]", capturedArgs)
}
}
+
+func TestHandleDelete_AliasSelector(t *testing.T) {
+ dir := t.TempDir()
+ oldRoot := taskAliasCacheRoot
+ oldNow := nowTaskAliasCache
+ taskAliasCacheRoot = func() (string, error) { return filepath.Join(dir, "hexai"), nil }
+ nowTaskAliasCache = func() time.Time { return time.Date(2026, 3, 26, 12, 0, 0, 0, time.UTC) }
+ defer func() {
+ taskAliasCacheRoot = oldRoot
+ nowTaskAliasCache = oldNow
+ }()
+
+ writeTaskAliasCacheForTest(t, taskAliasCache{
+ NextID: 1,
+ Entries: []taskAliasCacheEntry{
+ {UUID: "test-uuid-123", Alias: "0", CreatedAt: nowTaskAliasCache()},
+ },
+ })
+
+ var capturedArgs []string
+ d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ if len(args) == 2 && args[0] == "uuid:test-uuid-123" && args[1] == "export" {
+ io.WriteString(stdout, `[{"uuid":"test-uuid-123","description":"Task","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+ return 0, nil
+ }
+ capturedArgs = args
+ return 0, nil
+ }})
+
+ var stdout, stderr bytes.Buffer
+ code, _ := d.Dispatch(context.Background(), []string{"delete", "0"}, &bytes.Buffer{}, &stdout, &stderr)
+ if code != 0 {
+ t.Fatalf("delete code = %d stderr = %q", code, stderr.String())
+ }
+ if len(capturedArgs) != 2 || capturedArgs[0] != "uuid:test-uuid-123" || capturedArgs[1] != "delete" {
+ t.Fatalf("capturedArgs = %v, want [uuid:test-uuid-123 delete]", capturedArgs)
+ }
+}
diff --git a/internal/askcli/command_dep.go b/internal/askcli/command_dep.go
index a399c84..403afee 100644
--- a/internal/askcli/command_dep.go
+++ b/internal/askcli/command_dep.go
@@ -30,30 +30,30 @@ func (d Dispatcher) handleDepAddRm(ctx context.Context, args []string, stdout, s
io.WriteString(stderr, "error: ask dep add/rm requires <uuid> <dep-uuid>\n")
return 1, nil
}
- uuid := NormalizeUUID(args[2])
- if IsNumericID(uuid) {
- io.WriteString(stderr, RejectNumericID())
- return 1, nil
+ resolved, _, code, err := d.resolveTaskSelector(ctx, args[2], stderr)
+ if err != nil {
+ writeInfoError(stderr, err)
+ return code, nil
}
- depUUID := NormalizeUUID(args[3])
- if IsNumericID(depUUID) {
- io.WriteString(stderr, RejectNumericID())
- return 1, nil
+ dependency, _, code, err := d.resolveTaskSelector(ctx, args[3], stderr)
+ if err != nil {
+ writeInfoError(stderr, err)
+ return code, nil
}
op := args[1]
var modArg string
if op == "add" {
- modArg = "depends:" + depUUID
+ modArg = "depends:" + dependency.UUID
} else {
- modArg = "depends:-" + depUUID
+ modArg = "depends:-" + dependency.UUID
}
var outBuf bytes.Buffer
// uuid:<uuid> scopes the modify to exactly one task; modArg sets the dependency.
- code, err := d.runner.Run(ctx, []string{"uuid:" + uuid, "modify", modArg}, nil, &outBuf, io.Discard)
+ code, err = d.runner.Run(ctx, []string{"uuid:" + resolved.UUID, "modify", modArg}, nil, &outBuf, io.Discard)
if code != 0 {
return code, err
}
- io.WriteString(stdout, FormatSuccess(uuid))
+ io.WriteString(stdout, FormatSuccess(resolved.UUID))
return 0, nil
}
@@ -62,20 +62,10 @@ func (d Dispatcher) handleDepList(ctx context.Context, args []string, stdout, st
io.WriteString(stderr, "error: ask dep list requires <uuid>\n")
return 1, nil
}
- uuid := NormalizeUUID(args[2])
- if IsNumericID(uuid) {
- io.WriteString(stderr, RejectNumericID())
- return 1, nil
- }
- var outBuf bytes.Buffer
- code, err := d.runner.Run(ctx, []string{"uuid:" + uuid, "export"}, nil, &outBuf, stderr)
- if code != 0 {
- return code, err
- }
- tasks, err := ParseTaskExport(&outBuf)
+ _, tasks, code, err := d.resolveTaskSelector(ctx, args[2], stderr)
if err != nil {
- fmt.Fprintf(stderr, "error: failed to parse task data: %v\n", err)
- return 1, nil
+ writeInfoError(stderr, err)
+ return code, nil
}
if len(tasks) == 0 {
io.WriteString(stdout, "no dependencies\n")
diff --git a/internal/askcli/command_dep_test.go b/internal/askcli/command_dep_test.go
index 6139afa..8045df3 100644
--- a/internal/askcli/command_dep_test.go
+++ b/internal/askcli/command_dep_test.go
@@ -4,13 +4,24 @@ import (
"bytes"
"context"
"io"
+ "path/filepath"
"strings"
"testing"
+ "time"
)
func TestHandleDep_AddSuccess(t *testing.T) {
var capturedArgs []string
d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ if len(args) == 2 && args[1] == "export" {
+ switch args[0] {
+ case "uuid:uuid-1":
+ io.WriteString(stdout, `[{"uuid":"uuid-1","description":"Task","status":"pending","priority":"M","tags":[],"urgency":10,"depends":[]}]`)
+ case "uuid:uuid-2":
+ io.WriteString(stdout, `[{"uuid":"uuid-2","description":"Task","status":"pending","priority":"M","tags":[],"urgency":10,"depends":[]}]`)
+ }
+ return 0, nil
+ }
capturedArgs = args
return 0, nil
}})
@@ -30,6 +41,15 @@ func TestHandleDep_AddSuccess(t *testing.T) {
func TestHandleDep_RmSuccess(t *testing.T) {
d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ if len(args) == 2 && args[1] == "export" {
+ switch args[0] {
+ case "uuid:uuid-1":
+ io.WriteString(stdout, `[{"uuid":"uuid-1","description":"Task","status":"pending","priority":"M","tags":[],"urgency":10,"depends":[]}]`)
+ case "uuid:uuid-2":
+ io.WriteString(stdout, `[{"uuid":"uuid-2","description":"Task","status":"pending","priority":"M","tags":[],"urgency":10,"depends":[]}]`)
+ }
+ return 0, nil
+ }
return 0, nil
}})
var stdout, stderr bytes.Buffer
@@ -84,8 +104,12 @@ func TestHandleDep_AcceptUUIDPrefix(t *testing.T) {
var capturedArgs []string
export := `[{"uuid":"uuid-1","description":"T","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`
d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ if len(args) == 2 && args[1] == "export" {
+ capturedArgs = args
+ io.WriteString(stdout, export)
+ return 0, nil
+ }
capturedArgs = args
- io.WriteString(stdout, export)
return 0, nil
}})
var stdout, stderr bytes.Buffer
@@ -100,6 +124,50 @@ func TestHandleDep_AcceptUUIDPrefix(t *testing.T) {
}
}
+func TestHandleDep_AliasSelectors(t *testing.T) {
+ dir := t.TempDir()
+ oldRoot := taskAliasCacheRoot
+ oldNow := nowTaskAliasCache
+ taskAliasCacheRoot = func() (string, error) { return filepath.Join(dir, "hexai"), nil }
+ nowTaskAliasCache = func() time.Time { return time.Date(2026, 3, 26, 12, 0, 0, 0, time.UTC) }
+ defer func() {
+ taskAliasCacheRoot = oldRoot
+ nowTaskAliasCache = oldNow
+ }()
+
+ writeTaskAliasCacheForTest(t, taskAliasCache{
+ NextID: 2,
+ Entries: []taskAliasCacheEntry{
+ {UUID: "uuid-1", Alias: "0", CreatedAt: nowTaskAliasCache()},
+ {UUID: "uuid-2", Alias: "1", CreatedAt: nowTaskAliasCache()},
+ },
+ })
+
+ var capturedArgs []string
+ d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ if len(args) == 2 && args[1] == "export" {
+ switch args[0] {
+ case "uuid:uuid-1":
+ io.WriteString(stdout, `[{"uuid":"uuid-1","description":"T1","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+ case "uuid:uuid-2":
+ io.WriteString(stdout, `[{"uuid":"uuid-2","description":"T2","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+ }
+ return 0, nil
+ }
+ capturedArgs = args
+ return 0, nil
+ }})
+
+ var stdout, stderr bytes.Buffer
+ code, _ := d.Dispatch(context.Background(), []string{"dep", "add", "0", "1"}, nil, &stdout, &stderr)
+ if code != 0 {
+ t.Fatalf("dep add code = %d stderr = %q", code, stderr.String())
+ }
+ if len(capturedArgs) < 3 || capturedArgs[0] != "uuid:uuid-1" || capturedArgs[2] != "depends:uuid-2" {
+ t.Fatalf("capturedArgs = %v, want resolved alias UUIDs", capturedArgs)
+ }
+}
+
func TestHandleDep_NumericUUID(t *testing.T) {
d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
return 0, nil
diff --git a/internal/askcli/command_info_add.go b/internal/askcli/command_info_add.go
index 9a7b518..030cf62 100644
--- a/internal/askcli/command_info_add.go
+++ b/internal/askcli/command_info_add.go
@@ -31,11 +31,8 @@ func (d Dispatcher) handleInfo(ctx context.Context, args []string, stdout, stder
func (d Dispatcher) infoTasks(ctx context.Context, args []string, stderr io.Writer) ([]TaskExport, int, error) {
if len(args) >= 2 {
- uuid := NormalizeUUID(args[1])
- if IsNumericID(uuid) {
- return nil, 1, fmt.Errorf(strings.TrimSpace(RejectNumericID()))
- }
- return d.exportTasks(ctx, []string{"uuid:" + uuid, "export"}, stderr)
+ _, tasks, code, err := d.resolveTaskSelector(ctx, args[1], stderr)
+ return tasks, code, err
}
return d.startedInfoTasks(ctx, stderr)
}
diff --git a/internal/askcli/command_info_add_test.go b/internal/askcli/command_info_add_test.go
index 9bc13df..46996f7 100644
--- a/internal/askcli/command_info_add_test.go
+++ b/internal/askcli/command_info_add_test.go
@@ -4,8 +4,10 @@ import (
"bytes"
"context"
"io"
+ "path/filepath"
"strings"
"testing"
+ "time"
)
func TestHandleInfo_Success(t *testing.T) {
@@ -34,6 +36,42 @@ func TestHandleInfo_Success(t *testing.T) {
}
}
+func TestHandleInfo_AliasSelector(t *testing.T) {
+ dir := t.TempDir()
+ oldRoot := taskAliasCacheRoot
+ oldNow := nowTaskAliasCache
+ taskAliasCacheRoot = func() (string, error) { return filepath.Join(dir, "hexai"), nil }
+ nowTaskAliasCache = func() time.Time { return time.Date(2026, 3, 26, 12, 0, 0, 0, time.UTC) }
+ defer func() {
+ taskAliasCacheRoot = oldRoot
+ nowTaskAliasCache = oldNow
+ }()
+
+ writeTaskAliasCacheForTest(t, taskAliasCache{
+ NextID: 1,
+ Entries: []taskAliasCacheEntry{
+ {UUID: "test-uuid", Alias: "0", CreatedAt: nowTaskAliasCache()},
+ },
+ })
+
+ jsonData := `[{"uuid":"test-uuid","description":"Test task","status":"pending","priority":"H","tags":["cli"],"urgency":15.0,"depends":[]}]`
+ d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ if len(args) > 0 && strings.HasPrefix(args[0], "uuid:test-uuid") {
+ io.WriteString(stdout, jsonData)
+ }
+ return 0, nil
+ }})
+
+ var stdout, stderr bytes.Buffer
+ code, _ := d.Dispatch(context.Background(), []string{"info", "0"}, nil, &stdout, &stderr)
+ if code != 0 {
+ t.Fatalf("info code = %d, want 0", code)
+ }
+ if !strings.Contains(stdout.String(), "test-uuid") {
+ t.Fatalf("stdout = %q, want resolved UUID", stdout.String())
+ }
+}
+
func TestHandleInfo_NumericID(t *testing.T) {
d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
return 0, nil
diff --git a/internal/askcli/command_write.go b/internal/askcli/command_write.go
index 64000d7..afa1475 100644
--- a/internal/askcli/command_write.go
+++ b/internal/askcli/command_write.go
@@ -12,18 +12,18 @@ func (d Dispatcher) handleDenotate(ctx context.Context, args []string, stdout, s
io.WriteString(stderr, "error: ask denotate requires a UUID and text argument\n")
return 1, nil
}
- uuid := NormalizeUUID(args[1])
- if IsNumericID(uuid) {
- io.WriteString(stderr, RejectNumericID())
- return 1, nil
+ resolved, _, code, err := d.resolveTaskSelector(ctx, args[1], stderr)
+ if err != nil {
+ writeInfoError(stderr, err)
+ return code, nil
}
text := args[2]
var outBuf bytes.Buffer
- code, err := d.runner.Run(ctx, []string{"uuid:" + uuid, "denotate", text}, nil, &outBuf, io.Discard)
+ code, err = d.runner.Run(ctx, []string{"uuid:" + resolved.UUID, "denotate", text}, nil, &outBuf, io.Discard)
if code != 0 {
return code, err
}
- io.WriteString(stdout, FormatSuccess(uuid))
+ io.WriteString(stdout, FormatSuccess(resolved.UUID))
return 0, nil
}
@@ -32,18 +32,18 @@ func (d Dispatcher) handleModify(ctx context.Context, args []string, stdout, std
io.WriteString(stderr, "error: ask modify requires a UUID and modification args\n")
return 1, nil
}
- uuid := NormalizeUUID(args[1])
- if IsNumericID(uuid) {
- io.WriteString(stderr, RejectNumericID())
- return 1, nil
+ resolved, _, code, err := d.resolveTaskSelector(ctx, args[1], stderr)
+ if err != nil {
+ writeInfoError(stderr, err)
+ return code, nil
}
modArgs := args[2:]
var outBuf bytes.Buffer
- code, err := d.runner.Run(ctx, append([]string{"uuid:" + uuid, "modify"}, modArgs...), nil, &outBuf, io.Discard)
+ code, err = d.runner.Run(ctx, append([]string{"uuid:" + resolved.UUID, "modify"}, modArgs...), nil, &outBuf, io.Discard)
if code != 0 {
return code, err
}
- io.WriteString(stdout, FormatSuccess(uuid))
+ io.WriteString(stdout, FormatSuccess(resolved.UUID))
return 0, nil
}
@@ -52,18 +52,18 @@ func (d Dispatcher) handleAnnotate(ctx context.Context, args []string, stdout, s
io.WriteString(stderr, "error: ask annotate requires a UUID and note argument\n")
return 1, nil
}
- uuid := NormalizeUUID(args[1])
- if IsNumericID(uuid) {
- io.WriteString(stderr, RejectNumericID())
- return 1, nil
+ resolved, _, code, err := d.resolveTaskSelector(ctx, args[1], stderr)
+ if err != nil {
+ writeInfoError(stderr, err)
+ return code, nil
}
note := strings.Join(args[2:], " ")
var outBuf bytes.Buffer
- code, err := d.runner.Run(ctx, []string{"uuid:" + uuid, "annotate", note}, nil, &outBuf, io.Discard)
+ code, err = d.runner.Run(ctx, []string{"uuid:" + resolved.UUID, "annotate", note}, nil, &outBuf, io.Discard)
if code != 0 {
return code, err
}
- io.WriteString(stdout, FormatSuccess(uuid))
+ io.WriteString(stdout, FormatSuccess(resolved.UUID))
return 0, nil
}
@@ -72,19 +72,19 @@ func (d Dispatcher) handleStart(ctx context.Context, args []string, stdout, stde
io.WriteString(stderr, "error: ask start requires a UUID argument\n")
return 1, nil
}
- uuid := NormalizeUUID(args[1])
- if IsNumericID(uuid) {
- io.WriteString(stderr, RejectNumericID())
- return 1, nil
+ resolved, _, code, err := d.resolveTaskSelector(ctx, args[1], stderr)
+ if err != nil {
+ writeInfoError(stderr, err)
+ return code, nil
}
var outBuf bytes.Buffer
// uuid:<uuid> is used as the filter so taskwarrior selects the exact task;
// the action verb follows the filter.
- code, err := d.runner.Run(ctx, []string{"uuid:" + uuid, "start"}, nil, &outBuf, io.Discard)
+ code, err = d.runner.Run(ctx, []string{"uuid:" + resolved.UUID, "start"}, nil, &outBuf, io.Discard)
if code != 0 {
return code, err
}
- io.WriteString(stdout, FormatSuccess(uuid))
+ io.WriteString(stdout, FormatSuccess(resolved.UUID))
return 0, nil
}
@@ -93,17 +93,17 @@ func (d Dispatcher) handleStop(ctx context.Context, args []string, stdout, stder
io.WriteString(stderr, "error: ask stop requires a UUID argument\n")
return 1, nil
}
- uuid := NormalizeUUID(args[1])
- if IsNumericID(uuid) {
- io.WriteString(stderr, RejectNumericID())
- return 1, nil
+ resolved, _, code, err := d.resolveTaskSelector(ctx, args[1], stderr)
+ if err != nil {
+ writeInfoError(stderr, err)
+ return code, nil
}
var outBuf bytes.Buffer
- code, err := d.runner.Run(ctx, []string{"uuid:" + uuid, "stop"}, nil, &outBuf, io.Discard)
+ code, err = d.runner.Run(ctx, []string{"uuid:" + resolved.UUID, "stop"}, nil, &outBuf, io.Discard)
if code != 0 {
return code, err
}
- io.WriteString(stdout, FormatSuccess(uuid))
+ io.WriteString(stdout, FormatSuccess(resolved.UUID))
return 0, nil
}
@@ -112,17 +112,17 @@ func (d Dispatcher) handleDone(ctx context.Context, args []string, stdout, stder
io.WriteString(stderr, "error: ask done requires a UUID argument\n")
return 1, nil
}
- uuid := NormalizeUUID(args[1])
- if IsNumericID(uuid) {
- io.WriteString(stderr, RejectNumericID())
- return 1, nil
+ resolved, _, code, err := d.resolveTaskSelector(ctx, args[1], stderr)
+ if err != nil {
+ writeInfoError(stderr, err)
+ return code, nil
}
var outBuf bytes.Buffer
- code, err := d.runner.Run(ctx, []string{"uuid:" + uuid, "done"}, nil, &outBuf, io.Discard)
+ code, err = d.runner.Run(ctx, []string{"uuid:" + resolved.UUID, "done"}, nil, &outBuf, io.Discard)
if code != 0 {
return code, err
}
- io.WriteString(stdout, FormatSuccess(uuid))
+ io.WriteString(stdout, FormatSuccess(resolved.UUID))
return 0, nil
}
@@ -131,18 +131,18 @@ func (d Dispatcher) handlePriority(ctx context.Context, args []string, stdout, s
io.WriteString(stderr, "error: ask priority requires a UUID and priority (H/M/L)\n")
return 1, nil
}
- uuid := NormalizeUUID(args[1])
- if IsNumericID(uuid) {
- io.WriteString(stderr, RejectNumericID())
- return 1, nil
+ resolved, _, code, err := d.resolveTaskSelector(ctx, args[1], stderr)
+ if err != nil {
+ writeInfoError(stderr, err)
+ return code, nil
}
priority := args[2]
var outBuf bytes.Buffer
- code, err := d.runner.Run(ctx, []string{"uuid:" + uuid, "modify", "priority:" + priority}, nil, &outBuf, io.Discard)
+ code, err = d.runner.Run(ctx, []string{"uuid:" + resolved.UUID, "modify", "priority:" + priority}, nil, &outBuf, io.Discard)
if code != 0 {
return code, err
}
- io.WriteString(stdout, FormatSuccess(uuid))
+ io.WriteString(stdout, FormatSuccess(resolved.UUID))
return 0, nil
}
@@ -151,17 +151,17 @@ func (d Dispatcher) handleTag(ctx context.Context, args []string, stdout, stderr
io.WriteString(stderr, "error: ask tag requires a UUID and +/-tag\n")
return 1, nil
}
- uuid := NormalizeUUID(args[1])
- if IsNumericID(uuid) {
- io.WriteString(stderr, RejectNumericID())
- return 1, nil
+ resolved, _, code, err := d.resolveTaskSelector(ctx, args[1], stderr)
+ if err != nil {
+ writeInfoError(stderr, err)
+ return code, nil
}
tag := args[2]
var outBuf bytes.Buffer
- code, err := d.runner.Run(ctx, []string{"uuid:" + uuid, "modify", tag}, nil, &outBuf, io.Discard)
+ code, err = d.runner.Run(ctx, []string{"uuid:" + resolved.UUID, "modify", tag}, nil, &outBuf, io.Discard)
if code != 0 {
return code, err
}
- io.WriteString(stdout, FormatSuccess(uuid))
+ io.WriteString(stdout, FormatSuccess(resolved.UUID))
return 0, nil
}
diff --git a/internal/askcli/command_write_test.go b/internal/askcli/command_write_test.go
index 0b6cfb5..2ed5fc9 100644
--- a/internal/askcli/command_write_test.go
+++ b/internal/askcli/command_write_test.go
@@ -4,12 +4,56 @@ import (
"bytes"
"context"
"io"
+ "path/filepath"
"strings"
"testing"
+ "time"
)
+func TestHandleStart_AliasSelector(t *testing.T) {
+ dir := t.TempDir()
+ oldRoot := taskAliasCacheRoot
+ oldNow := nowTaskAliasCache
+ taskAliasCacheRoot = func() (string, error) { return filepath.Join(dir, "hexai"), nil }
+ nowTaskAliasCache = func() time.Time { return time.Date(2026, 3, 26, 12, 0, 0, 0, time.UTC) }
+ defer func() {
+ taskAliasCacheRoot = oldRoot
+ nowTaskAliasCache = oldNow
+ }()
+
+ writeTaskAliasCacheForTest(t, taskAliasCache{
+ NextID: 1,
+ Entries: []taskAliasCacheEntry{
+ {UUID: "test-uuid", Alias: "0", CreatedAt: nowTaskAliasCache()},
+ },
+ })
+
+ var capturedArgs []string
+ d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ if len(args) == 2 && args[0] == "uuid:test-uuid" && args[1] == "export" {
+ io.WriteString(stdout, `[{"uuid":"test-uuid","description":"Task","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+ return 0, nil
+ }
+ capturedArgs = args
+ return 0, nil
+ }})
+
+ var stdout, stderr bytes.Buffer
+ code, _ := d.Dispatch(context.Background(), []string{"start", "0"}, &bytes.Buffer{}, &stdout, &stderr)
+ if code != 0 {
+ t.Fatalf("start code = %d stderr = %q", code, stderr.String())
+ }
+ if len(capturedArgs) != 2 || capturedArgs[0] != "uuid:test-uuid" || capturedArgs[1] != "start" {
+ t.Fatalf("capturedArgs = %v, want [uuid:test-uuid start]", capturedArgs)
+ }
+}
+
func TestHandleDenotate_Success(t *testing.T) {
d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ if len(args) == 2 && args[0] == "uuid:test-uuid" && args[1] == "export" {
+ io.WriteString(stdout, `[{"uuid":"test-uuid","description":"Task","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+ return 0, nil
+ }
return 0, nil
}})
var stdout, stderr bytes.Buffer
@@ -51,6 +95,10 @@ func TestHandleDenotate_MissingArgs(t *testing.T) {
func TestHandleModify_Success(t *testing.T) {
d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ if len(args) == 2 && args[0] == "uuid:test-uuid" && args[1] == "export" {
+ io.WriteString(stdout, `[{"uuid":"test-uuid","description":"Task","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+ return 0, nil
+ }
return 0, nil
}})
var stdout, stderr bytes.Buffer
@@ -77,6 +125,10 @@ func TestHandleModify_NumericID(t *testing.T) {
func TestHandleAnnotate_Success(t *testing.T) {
d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ if len(args) == 2 && args[0] == "uuid:test-uuid" && args[1] == "export" {
+ io.WriteString(stdout, `[{"uuid":"test-uuid","description":"Task","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+ return 0, nil
+ }
return 0, nil
}})
var stdout, stderr bytes.Buffer
@@ -103,6 +155,10 @@ func TestHandleAnnotate_MissingArgs(t *testing.T) {
func TestHandleStart_Success(t *testing.T) {
d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ if len(args) == 2 && args[0] == "uuid:test-uuid" && args[1] == "export" {
+ io.WriteString(stdout, `[{"uuid":"test-uuid","description":"Task","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+ return 0, nil
+ }
return 0, nil
}})
var stdout, stderr bytes.Buffer
@@ -129,6 +185,10 @@ func TestHandleStart_MissingUUID(t *testing.T) {
func TestHandleStop_Success(t *testing.T) {
d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ if len(args) == 2 && args[0] == "uuid:test-uuid" && args[1] == "export" {
+ io.WriteString(stdout, `[{"uuid":"test-uuid","description":"Task","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+ return 0, nil
+ }
return 0, nil
}})
var stdout, stderr bytes.Buffer
@@ -140,6 +200,10 @@ func TestHandleStop_Success(t *testing.T) {
func TestHandleDone_Success(t *testing.T) {
d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ if len(args) == 2 && args[0] == "uuid:test-uuid" && args[1] == "export" {
+ io.WriteString(stdout, `[{"uuid":"test-uuid","description":"Task","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+ return 0, nil
+ }
return 0, nil
}})
var stdout, stderr bytes.Buffer
@@ -151,6 +215,10 @@ func TestHandleDone_Success(t *testing.T) {
func TestHandlePriority_Success(t *testing.T) {
d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ if len(args) == 2 && args[0] == "uuid:test-uuid" && args[1] == "export" {
+ io.WriteString(stdout, `[{"uuid":"test-uuid","description":"Task","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+ return 0, nil
+ }
return 0, nil
}})
var stdout, stderr bytes.Buffer
@@ -174,6 +242,10 @@ func TestHandlePriority_MissingArgs(t *testing.T) {
func TestHandleTag_Success(t *testing.T) {
d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ if len(args) == 2 && args[0] == "uuid:test-uuid" && args[1] == "export" {
+ io.WriteString(stdout, `[{"uuid":"test-uuid","description":"Task","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+ return 0, nil
+ }
return 0, nil
}})
var stdout, stderr bytes.Buffer
@@ -217,6 +289,10 @@ func TestAllWriteHandlers_PassCorrectArgs(t *testing.T) {
t.Run(tc.subcommand, func(t *testing.T) {
var capturedArgs []string
d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ if len(args) == 2 && args[1] == "export" {
+ io.WriteString(stdout, `[{"uuid":"my-uuid","description":"Task","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+ return 0, nil
+ }
capturedArgs = args
return 0, nil
}})
@@ -257,6 +333,10 @@ func TestAllWriteHandlers_AcceptUUIDPrefix(t *testing.T) {
t.Run(tc.subcommand, func(t *testing.T) {
var capturedArgs []string
d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ if len(args) == 2 && args[1] == "export" {
+ io.WriteString(stdout, `[{"uuid":"my-uuid","description":"Task","status":"pending","priority":"M","tags":[],"urgency":0,"depends":[]}]`)
+ return 0, nil
+ }
capturedArgs = args
return 0, nil
}})
diff --git a/internal/askcli/task_alias_cache.go b/internal/askcli/task_alias_cache.go
index a914e6b..c6a0ba2 100644
--- a/internal/askcli/task_alias_cache.go
+++ b/internal/askcli/task_alias_cache.go
@@ -168,6 +168,30 @@ func (c *taskAliasCache) ensureAlias(uuid string, now time.Time) (string, bool)
return alias, true
}
+func (c *taskAliasCache) lookupUUIDByAlias(alias string, now time.Time) (string, bool, bool) {
+ for i := range c.Entries {
+ if c.Entries[i].Alias != alias {
+ continue
+ }
+ changed := !c.Entries[i].LastAccessedAt.Equal(now)
+ c.Entries[i].LastAccessedAt = now
+ return c.Entries[i].UUID, true, changed
+ }
+ return "", false, false
+}
+
+func (c *taskAliasCache) lookupAliasByUUID(uuid string, now time.Time) (string, bool, bool) {
+ for i := range c.Entries {
+ if c.Entries[i].UUID != uuid {
+ continue
+ }
+ changed := !c.Entries[i].LastAccessedAt.Equal(now)
+ c.Entries[i].LastAccessedAt = now
+ return c.Entries[i].Alias, true, changed
+ }
+ return "", false, false
+}
+
func (c taskAliasCache) save(path string) error {
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
return fmt.Errorf("create task alias cache dir: %w", err)
diff --git a/internal/askcli/task_selector.go b/internal/askcli/task_selector.go
new file mode 100644
index 0000000..7702153
--- /dev/null
+++ b/internal/askcli/task_selector.go
@@ -0,0 +1,119 @@
+package askcli
+
+import (
+ "context"
+ "fmt"
+ "io"
+ "strings"
+)
+
+type resolvedTaskSelector struct {
+ Input string
+ UUID string
+ Alias string
+ UsedAlias bool
+}
+
+func (d Dispatcher) resolveTaskSelector(ctx context.Context, selector string, stderr io.Writer) (resolvedTaskSelector, []TaskExport, int, error) {
+ normalized, requiresLookup, err := normalizeTaskSelectorInput(selector)
+ if err != nil {
+ return resolvedTaskSelector{}, nil, 1, err
+ }
+
+ resolved, err := resolveTaskSelectorFromCache(normalized, requiresLookup)
+ if err != nil {
+ return resolvedTaskSelector{}, nil, 1, err
+ }
+
+ tasks, code, err := d.exportTasks(ctx, []string{"uuid:" + resolved.UUID, "export"}, stderr)
+ if err != nil {
+ if resolved.UsedAlias && strings.Contains(err.Error(), "task not found") {
+ return resolvedTaskSelector{}, nil, 1, fmt.Errorf("alias %q is stale: task %s was not found", selector, resolved.UUID)
+ }
+ return resolvedTaskSelector{}, nil, code, err
+ }
+
+ aliases, err := ensureTaskAliases(tasks)
+ if err != nil {
+ return resolvedTaskSelector{}, nil, 1, err
+ }
+ if alias, ok := aliases[resolved.UUID]; ok {
+ resolved.Alias = alias
+ }
+ return resolved, tasks, 0, nil
+}
+
+func normalizeTaskSelectorInput(selector string) (string, bool, error) {
+ normalized := NormalizeUUID(selector)
+ if selector != normalized && IsNumericID(normalized) {
+ return "", false, fmt.Errorf(strings.TrimSpace(RejectNumericID()))
+ }
+ return normalized, selector == normalized, nil
+}
+
+func resolveTaskSelectorFromCache(selector string, allowAlias bool) (resolvedTaskSelector, error) {
+ resolved := resolvedTaskSelector{Input: selector, UUID: selector}
+ if !allowAlias || !looksLikeTaskAlias(selector) {
+ return resolved, nil
+ }
+
+ cache, path, err := loadTaskAliasCache()
+ if err != nil {
+ return resolvedTaskSelector{}, err
+ }
+
+ now := nowTaskAliasCache().UTC()
+ changed := cache.prune(now)
+ uuidFromAlias, aliasFound, aliasChanged := cache.lookupUUIDByAlias(selector, now)
+ changed = changed || aliasChanged
+ aliasForUUID, uuidFound, uuidChanged := cache.lookupAliasByUUID(selector, now)
+ changed = changed || uuidChanged
+
+ switch {
+ case aliasFound && uuidFound && uuidFromAlias != selector:
+ if changed {
+ if err := cache.save(path); err != nil {
+ return resolvedTaskSelector{}, err
+ }
+ }
+ return resolvedTaskSelector{}, fmt.Errorf("task selector %q is ambiguous: it matches alias for %s and UUID %s; use uuid:%s to force UUID", selector, uuidFromAlias, selector, selector)
+ case aliasFound:
+ if changed {
+ if err := cache.save(path); err != nil {
+ return resolvedTaskSelector{}, err
+ }
+ }
+ return resolvedTaskSelector{
+ Input: selector,
+ UUID: uuidFromAlias,
+ Alias: selector,
+ UsedAlias: true,
+ }, nil
+ case uuidFound:
+ if changed {
+ if err := cache.save(path); err != nil {
+ return resolvedTaskSelector{}, err
+ }
+ }
+ return resolvedTaskSelector{
+ Input: selector,
+ UUID: selector,
+ Alias: aliasForUUID,
+ }, nil
+ default:
+ if IsNumericID(selector) {
+ return resolvedTaskSelector{}, fmt.Errorf(strings.TrimSpace(RejectNumericID()))
+ }
+ if changed {
+ if err := cache.save(path); err != nil {
+ return resolvedTaskSelector{}, err
+ }
+ }
+ return resolvedTaskSelector{}, fmt.Errorf("task selector %q did not match a known alias; use uuid:%s to force UUID", selector, selector)
+ }
+}
+
+func looksLikeTaskAlias(selector string) bool {
+ _, ok := decodeTaskAliasID(selector)
+ return ok && !strings.Contains(selector, "-")
+}
diff --git a/internal/askcli/task_selector_test.go b/internal/askcli/task_selector_test.go
new file mode 100644
index 0000000..7e60665
--- /dev/null
+++ b/internal/askcli/task_selector_test.go
@@ -0,0 +1,157 @@
+package askcli
+
+import (
+ "bytes"
+ "context"
+ "encoding/json"
+ "io"
+ "os"
+ "path/filepath"
+ "strings"
+ "testing"
+ "time"
+)
+
+func TestResolveTaskSelectorFromCache_TouchesAliasEntry(t *testing.T) {
+ dir := t.TempDir()
+ oldNow := nowTaskAliasCache
+ oldRoot := taskAliasCacheRoot
+ nowTaskAliasCache = func() time.Time { return time.Date(2026, 3, 26, 12, 0, 0, 0, time.UTC) }
+ taskAliasCacheRoot = func() (string, error) { return filepath.Join(dir, "hexai"), nil }
+ defer func() {
+ nowTaskAliasCache = oldNow
+ taskAliasCacheRoot = oldRoot
+ }()
+
+ writeTaskAliasCacheForTest(t, taskAliasCache{
+ NextID: 2,
+ Entries: []taskAliasCacheEntry{
+ {
+ UUID: "task-uuid-1",
+ Alias: "0",
+ CreatedAt: time.Date(2026, 3, 20, 12, 0, 0, 0, time.UTC),
+ LastAccessedAt: time.Date(2026, 3, 21, 12, 0, 0, 0, time.UTC),
+ },
+ },
+ })
+
+ resolved, err := resolveTaskSelectorFromCache("0", true)
+ if err != nil {
+ t.Fatalf("resolveTaskSelectorFromCache returned error: %v", err)
+ }
+ if !resolved.UsedAlias || resolved.UUID != "task-uuid-1" {
+ t.Fatalf("resolved = %+v, want alias hit for task-uuid-1", resolved)
+ }
+
+ cache := readTaskAliasCacheSnapshot(t)
+ entry := findTaskAliasEntry(t, cache, "task-uuid-1")
+ if got := entry.LastAccessedAt; !got.Equal(nowTaskAliasCache()) {
+ t.Fatalf("LastAccessedAt = %s, want %s", got, nowTaskAliasCache())
+ }
+}
+
+func TestResolveTaskSelectorFromCache_MissingAlias(t *testing.T) {
+ dir := t.TempDir()
+ oldRoot := taskAliasCacheRoot
+ taskAliasCacheRoot = func() (string, error) { return filepath.Join(dir, "hexai"), nil }
+ defer func() { taskAliasCacheRoot = oldRoot }()
+
+ _, err := resolveTaskSelectorFromCache("a", true)
+ if err == nil {
+ t.Fatal("resolveTaskSelectorFromCache returned nil error, want missing alias failure")
+ }
+ if !strings.Contains(err.Error(), `did not match a known alias`) {
+ t.Fatalf("err = %q, want missing alias message", err)
+ }
+}
+
+func TestResolveTaskSelectorFromCache_AmbiguousSelector(t *testing.T) {
+ dir := t.TempDir()
+ oldRoot := taskAliasCacheRoot
+ oldNow := nowTaskAliasCache
+ taskAliasCacheRoot = func() (string, error) { return filepath.Join(dir, "hexai"), nil }
+ nowTaskAliasCache = func() time.Time { return time.Date(2026, 3, 26, 12, 0, 0, 0, time.UTC) }
+ defer func() {
+ taskAliasCacheRoot = oldRoot
+ nowTaskAliasCache = oldNow
+ }()
+
+ writeTaskAliasCacheForTest(t, taskAliasCache{
+ NextID: 11,
+ Entries: []taskAliasCacheEntry{
+ {UUID: "a", Alias: "1", CreatedAt: nowTaskAliasCache()},
+ {UUID: "task-uuid-2", Alias: "a", CreatedAt: nowTaskAliasCache()},
+ },
+ })
+
+ _, err := resolveTaskSelectorFromCache("a", true)
+ if err == nil {
+ t.Fatal("resolveTaskSelectorFromCache returned nil error, want ambiguity")
+ }
+ if !strings.Contains(err.Error(), "ambiguous") {
+ t.Fatalf("err = %q, want ambiguity message", err)
+ }
+}
+
+func TestHandleInfo_StaleAlias(t *testing.T) {
+ dir := t.TempDir()
+ oldRoot := taskAliasCacheRoot
+ oldNow := nowTaskAliasCache
+ taskAliasCacheRoot = func() (string, error) { return filepath.Join(dir, "hexai"), nil }
+ nowTaskAliasCache = func() time.Time { return time.Date(2026, 3, 26, 12, 0, 0, 0, time.UTC) }
+ defer func() {
+ taskAliasCacheRoot = oldRoot
+ nowTaskAliasCache = oldNow
+ }()
+
+ writeTaskAliasCacheForTest(t, taskAliasCache{
+ NextID: 1,
+ Entries: []taskAliasCacheEntry{
+ {UUID: "task-uuid-1", Alias: "0", CreatedAt: nowTaskAliasCache()},
+ },
+ })
+
+ d := NewDispatcher(&spyRunner{runFn: func(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
+ if len(args) == 2 && args[0] == "uuid:task-uuid-1" && args[1] == "export" {
+ io.WriteString(stdout, "[]")
+ }
+ return 0, nil
+ }})
+
+ var stdout, stderr bytes.Buffer
+ code, _ := d.Dispatch(context.Background(), []string{"info", "0"}, nil, &stdout, &stderr)
+ if code != 1 {
+ t.Fatalf("info code = %d, want 1 for stale alias", code)
+ }
+ if !strings.Contains(stderr.String(), `alias "0" is stale`) {
+ t.Fatalf("stderr = %q, want stale alias message", stderr.String())
+ }
+}
+
+func writeTaskAliasCacheForTest(t *testing.T, cache taskAliasCache) {
+ t.Helper()
+ path, err := taskAliasCachePath()
+ if err != nil {
+ t.Fatalf("taskAliasCachePath: %v", err)
+ }
+ if err := cache.save(path); err != nil {
+ t.Fatalf("cache.save: %v", err)
+ }
+}
+
+func readTaskAliasCacheSnapshot(t *testing.T) taskAliasCache {
+ t.Helper()
+ path, err := taskAliasCachePath()
+ if err != nil {
+ t.Fatalf("taskAliasCachePath: %v", err)
+ }
+ data, err := os.ReadFile(path)
+ if err != nil {
+ t.Fatalf("os.ReadFile(%s): %v", path, err)
+ }
+ var cache taskAliasCache
+ if err := json.Unmarshal(data, &cache); err != nil {
+ t.Fatalf("json.Unmarshal: %v", err)
+ }
+ return cache
+}
generated by cgit v1.2.3 (git 2.25.1) at 2026-05-17 16:19:28 +0000