* fix: enable auto-export by default with canonical issues.jsonl name (GH#2973) Users expected JSONL export to refresh automatically but export.auto defaulted to false, requiring explicit opt-in. Also the default filename (export.jsonl) didn't match the canonical issues.jsonl used in docs and git hooks. Change defaults: export.auto=true, export.path=issues.jsonl, export.git-add=true so viewers (bv) and git workflows see fresh data without extra configuration. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * feat(init): add auto-export prompt and document export.* config (GH#2973) Interactive bd init now asks whether to enable auto-export (default: yes). Users can opt out during setup instead of discovering the setting later. Also documents the export.* config namespace in bd config --help with all four keys (export.auto, export.path, export.interval, export.git-add) and adds export examples. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * docs: document export.* auto-export config keys (GH#2973) Document the export.auto/path/interval/git-add keys in docs/CONFIG.md and note the default-on switch in CHANGELOG.md [Unreleased]. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(export): don't prime throttle on empty init and skip git-add without git (GH#2973) Review feedback on #3204 surfaced two regressions in the default-on auto-export path: 1. bd init's PersistentPostRun fired maybeAutoExport with zero issues, writing an empty .beads/issues.jsonl and saving export-state.json with the current dolt commit + timestamp. The next `bd create` was then throttled for up to export.interval (default 60s) because the timestamp check in maybeAutoExport returned before considering the new commit, leaving issues.jsonl stale on fresh repos. Skip saving state and remove the empty file when the export produced no issues and no memories. The next write runs a real export immediately. 2. export.git-add defaulting to true emitted `Warning: auto-export: git add failed: exit status 128` on every write in the supported standalone BEADS_DIR flow where init intentionally skips `git init`. Gate the git add call on isGitRepo() so standalone users get silent, working auto-export. Adds a scripttest regression guard for the init -> immediate create path. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * test(memory): disable auto-export in concurrent test (GH#2973) TestEmbeddedMemoryConcurrent started failing on this branch after auto-export became the default: every concurrent 'bd remember'/'bd forget' call now fires maybeAutoExport, which reads store state after the write. Under 8-worker contention this intermittently leaves a forgotten key visible to 'bd memories'. The test exercises memory concurrency, not export behavior; opt it out of auto-export so the signal stays focused. Followup: investigate the race between write commit and post-write auto-export read in embedded Dolt concurrent paths. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
341 lines
9.5 KiB
Go
341 lines
9.5 KiB
Go
//go:build cgo
|
|
|
|
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"os/exec"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
)
|
|
|
|
// bdRemember runs "bd remember" with the given args and returns stdout.
|
|
func bdRemember(t *testing.T, bd, dir string, args ...string) string {
|
|
t.Helper()
|
|
fullArgs := append([]string{"remember"}, args...)
|
|
cmd := exec.Command(bd, fullArgs...)
|
|
cmd.Dir = dir
|
|
cmd.Env = bdEnv(dir)
|
|
out, err := cmd.CombinedOutput()
|
|
if err != nil {
|
|
t.Fatalf("bd remember %s failed: %v\n%s", strings.Join(args, " "), err, out)
|
|
}
|
|
return string(out)
|
|
}
|
|
|
|
// bdRememberFail runs "bd remember" expecting failure.
|
|
func bdRememberFail(t *testing.T, bd, dir string, args ...string) string {
|
|
t.Helper()
|
|
fullArgs := append([]string{"remember"}, args...)
|
|
cmd := exec.Command(bd, fullArgs...)
|
|
cmd.Dir = dir
|
|
cmd.Env = bdEnv(dir)
|
|
out, err := cmd.CombinedOutput()
|
|
if err == nil {
|
|
t.Fatalf("expected bd remember %s to fail, but succeeded:\n%s", strings.Join(args, " "), out)
|
|
}
|
|
return string(out)
|
|
}
|
|
|
|
// bdRecall runs "bd recall" with the given args and returns stdout.
|
|
func bdRecall(t *testing.T, bd, dir string, args ...string) string {
|
|
t.Helper()
|
|
fullArgs := append([]string{"recall"}, args...)
|
|
cmd := exec.Command(bd, fullArgs...)
|
|
cmd.Dir = dir
|
|
cmd.Env = bdEnv(dir)
|
|
out, err := cmd.CombinedOutput()
|
|
if err != nil {
|
|
t.Fatalf("bd recall %s failed: %v\n%s", strings.Join(args, " "), err, out)
|
|
}
|
|
return string(out)
|
|
}
|
|
|
|
// bdRecallFail runs "bd recall" expecting failure.
|
|
func bdRecallFail(t *testing.T, bd, dir string, args ...string) string {
|
|
t.Helper()
|
|
fullArgs := append([]string{"recall"}, args...)
|
|
cmd := exec.Command(bd, fullArgs...)
|
|
cmd.Dir = dir
|
|
cmd.Env = bdEnv(dir)
|
|
out, err := cmd.CombinedOutput()
|
|
if err == nil {
|
|
t.Fatalf("expected bd recall %s to fail, but succeeded:\n%s", strings.Join(args, " "), out)
|
|
}
|
|
return string(out)
|
|
}
|
|
|
|
// bdMemories runs "bd memories" with the given args and returns stdout.
|
|
func bdMemories(t *testing.T, bd, dir string, args ...string) string {
|
|
t.Helper()
|
|
fullArgs := append([]string{"memories"}, args...)
|
|
cmd := exec.Command(bd, fullArgs...)
|
|
cmd.Dir = dir
|
|
cmd.Env = bdEnv(dir)
|
|
out, err := cmd.CombinedOutput()
|
|
if err != nil {
|
|
t.Fatalf("bd memories %s failed: %v\n%s", strings.Join(args, " "), err, out)
|
|
}
|
|
return string(out)
|
|
}
|
|
|
|
// bdForget runs "bd forget" with the given args and returns stdout.
|
|
func bdForget(t *testing.T, bd, dir string, args ...string) string {
|
|
t.Helper()
|
|
fullArgs := append([]string{"forget"}, args...)
|
|
cmd := exec.Command(bd, fullArgs...)
|
|
cmd.Dir = dir
|
|
cmd.Env = bdEnv(dir)
|
|
out, err := cmd.CombinedOutput()
|
|
if err != nil {
|
|
t.Fatalf("bd forget %s failed: %v\n%s", strings.Join(args, " "), err, out)
|
|
}
|
|
return string(out)
|
|
}
|
|
|
|
// bdForgetFail runs "bd forget" expecting failure.
|
|
func bdForgetFail(t *testing.T, bd, dir string, args ...string) string {
|
|
t.Helper()
|
|
fullArgs := append([]string{"forget"}, args...)
|
|
cmd := exec.Command(bd, fullArgs...)
|
|
cmd.Dir = dir
|
|
cmd.Env = bdEnv(dir)
|
|
out, err := cmd.CombinedOutput()
|
|
if err == nil {
|
|
t.Fatalf("expected bd forget %s to fail, but succeeded:\n%s", strings.Join(args, " "), out)
|
|
}
|
|
return string(out)
|
|
}
|
|
|
|
func TestEmbeddedMemory(t *testing.T) {
|
|
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
|
|
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
|
|
}
|
|
t.Parallel()
|
|
|
|
bd := buildEmbeddedBD(t)
|
|
dir, _, _ := bdInit(t, bd, "--prefix", "tm")
|
|
|
|
// ===== Remember and Recall =====
|
|
|
|
t.Run("remember_and_recall", func(t *testing.T) {
|
|
bdRemember(t, bd, dir, "always run tests with -race flag")
|
|
// Recall using auto-generated key — list memories to find it
|
|
out := bdMemories(t, bd, dir)
|
|
if !strings.Contains(out, "always run tests with -race flag") {
|
|
t.Errorf("expected memory in list: %s", out)
|
|
}
|
|
})
|
|
|
|
t.Run("remember_with_key", func(t *testing.T) {
|
|
bdRemember(t, bd, dir, "auth module uses JWT not sessions", "--key", "auth-jwt")
|
|
out := bdRecall(t, bd, dir, "auth-jwt")
|
|
if !strings.Contains(out, "JWT") {
|
|
t.Errorf("expected 'JWT' in recall output: %s", out)
|
|
}
|
|
})
|
|
|
|
t.Run("remember_overwrite", func(t *testing.T) {
|
|
bdRemember(t, bd, dir, "first version", "--key", "overwrite-test")
|
|
bdRemember(t, bd, dir, "second version", "--key", "overwrite-test")
|
|
out := bdRecall(t, bd, dir, "overwrite-test")
|
|
if !strings.Contains(out, "second version") {
|
|
t.Errorf("expected 'second version' after overwrite: %s", out)
|
|
}
|
|
})
|
|
|
|
// ===== Memories List =====
|
|
|
|
t.Run("memories_list", func(t *testing.T) {
|
|
out := bdMemories(t, bd, dir)
|
|
// Should show at least the memories we stored above
|
|
if !strings.Contains(out, "auth-jwt") {
|
|
t.Errorf("expected 'auth-jwt' in memories list: %s", out)
|
|
}
|
|
})
|
|
|
|
t.Run("memories_search", func(t *testing.T) {
|
|
bdRemember(t, bd, dir, "dolt phantom DBs hide in three places", "--key", "dolt-phantoms")
|
|
out := bdMemories(t, bd, dir, "dolt")
|
|
if !strings.Contains(out, "dolt") {
|
|
t.Errorf("expected 'dolt' related memory in search: %s", out)
|
|
}
|
|
})
|
|
|
|
t.Run("memories_search_no_match", func(t *testing.T) {
|
|
out := bdMemories(t, bd, dir, "zzz_nonexistent_term_xyz")
|
|
// Should succeed but show no results or empty
|
|
_ = out
|
|
})
|
|
|
|
// ===== Forget =====
|
|
|
|
t.Run("forget", func(t *testing.T) {
|
|
bdRemember(t, bd, dir, "temporary memory to forget", "--key", "forget-me")
|
|
out := bdRecall(t, bd, dir, "forget-me")
|
|
if !strings.Contains(out, "temporary memory") {
|
|
t.Fatalf("expected memory before forget: %s", out)
|
|
}
|
|
bdForget(t, bd, dir, "forget-me")
|
|
// After forget, recall should fail
|
|
bdRecallFail(t, bd, dir, "forget-me")
|
|
})
|
|
|
|
// ===== Error Cases =====
|
|
|
|
t.Run("recall_missing_key", func(t *testing.T) {
|
|
bdRecallFail(t, bd, dir, "nonexistent-key-xyz")
|
|
})
|
|
|
|
t.Run("forget_missing_key", func(t *testing.T) {
|
|
bdForgetFail(t, bd, dir, "nonexistent-key-xyz")
|
|
})
|
|
|
|
t.Run("remember_no_args", func(t *testing.T) {
|
|
bdRememberFail(t, bd, dir)
|
|
})
|
|
|
|
t.Run("recall_no_args", func(t *testing.T) {
|
|
bdRecallFail(t, bd, dir)
|
|
})
|
|
|
|
t.Run("forget_no_args", func(t *testing.T) {
|
|
bdForgetFail(t, bd, dir)
|
|
})
|
|
}
|
|
|
|
// TestEmbeddedMemoryConcurrent exercises memory operations concurrently.
|
|
func TestEmbeddedMemoryConcurrent(t *testing.T) {
|
|
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
|
|
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
|
|
}
|
|
t.Parallel()
|
|
|
|
bd := buildEmbeddedBD(t)
|
|
dir, _, _ := bdInit(t, bd, "--prefix", "mx")
|
|
|
|
// Disable auto-export: this test exercises concurrent memory
|
|
// flock contention, not export behavior. With export.auto=true
|
|
// (the default since GH#2973), 8 concurrent writers also trigger
|
|
// post-write read paths that race with in-flight commits.
|
|
disableAutoExport := exec.Command(bd, "config", "set", "export.auto", "false")
|
|
disableAutoExport.Dir = dir
|
|
disableAutoExport.Env = bdEnv(dir)
|
|
if out, err := disableAutoExport.CombinedOutput(); err != nil {
|
|
t.Fatalf("disable export.auto: %v\n%s", err, out)
|
|
}
|
|
|
|
const numWorkers = 8
|
|
|
|
type workerResult struct {
|
|
worker int
|
|
err error
|
|
}
|
|
|
|
results := make([]workerResult, numWorkers)
|
|
var wg sync.WaitGroup
|
|
wg.Add(numWorkers)
|
|
|
|
for w := 0; w < numWorkers; w++ {
|
|
go func(worker int) {
|
|
defer wg.Done()
|
|
r := workerResult{worker: worker}
|
|
|
|
// Each worker stores memories with unique keys
|
|
for i := 0; i < 3; i++ {
|
|
key := fmt.Sprintf("w%d-mem%d", worker, i)
|
|
content := fmt.Sprintf("worker %d memory %d content", worker, i)
|
|
|
|
cmd := exec.Command(bd, "remember", content, "--key", key)
|
|
cmd.Dir = dir
|
|
cmd.Env = bdEnv(dir)
|
|
out, err := cmd.CombinedOutput()
|
|
if err != nil {
|
|
r.err = fmt.Errorf("remember %s: %v\n%s", key, err, out)
|
|
results[worker] = r
|
|
return
|
|
}
|
|
}
|
|
|
|
// Recall each memory
|
|
for i := 0; i < 3; i++ {
|
|
key := fmt.Sprintf("w%d-mem%d", worker, i)
|
|
expected := fmt.Sprintf("worker %d memory %d content", worker, i)
|
|
|
|
cmd := exec.Command(bd, "recall", key)
|
|
cmd.Dir = dir
|
|
cmd.Env = bdEnv(dir)
|
|
out, err := cmd.CombinedOutput()
|
|
if err != nil {
|
|
r.err = fmt.Errorf("recall %s: %v\n%s", key, err, out)
|
|
results[worker] = r
|
|
return
|
|
}
|
|
if !strings.Contains(string(out), expected) {
|
|
r.err = fmt.Errorf("recall %s: expected %q, got %q", key, expected, string(out))
|
|
results[worker] = r
|
|
return
|
|
}
|
|
}
|
|
|
|
// Forget one memory
|
|
forgetKey := fmt.Sprintf("w%d-mem0", worker)
|
|
cmd := exec.Command(bd, "forget", forgetKey)
|
|
cmd.Dir = dir
|
|
cmd.Env = bdEnv(dir)
|
|
out, err := cmd.CombinedOutput()
|
|
if err != nil {
|
|
r.err = fmt.Errorf("forget %s: %v\n%s", forgetKey, err, out)
|
|
results[worker] = r
|
|
return
|
|
}
|
|
|
|
// List memories
|
|
cmd = exec.Command(bd, "memories")
|
|
cmd.Dir = dir
|
|
cmd.Env = bdEnv(dir)
|
|
out, err = cmd.CombinedOutput()
|
|
if err != nil {
|
|
r.err = fmt.Errorf("memories: %v\n%s", err, out)
|
|
results[worker] = r
|
|
return
|
|
}
|
|
|
|
results[worker] = r
|
|
}(w)
|
|
}
|
|
wg.Wait()
|
|
|
|
for _, r := range results {
|
|
if r.err != nil && !strings.Contains(r.err.Error(), "one writer at a time") {
|
|
t.Errorf("worker %d failed: %v", r.worker, r.err)
|
|
}
|
|
}
|
|
|
|
// Verify memories only for workers that succeeded (err==nil).
|
|
// With exclusive flock, some workers may fail with "one writer at a time".
|
|
out := bdMemories(t, bd, dir)
|
|
var successCount int
|
|
for _, r := range results {
|
|
if r.err != nil {
|
|
continue
|
|
}
|
|
successCount++
|
|
w := r.worker
|
|
forgottenKey := fmt.Sprintf("w%d-mem0", w)
|
|
if strings.Contains(out, forgottenKey) {
|
|
t.Errorf("expected %s to be forgotten", forgottenKey)
|
|
}
|
|
for i := 1; i < 3; i++ {
|
|
key := fmt.Sprintf("w%d-mem%d", w, i)
|
|
if !strings.Contains(out, key) {
|
|
t.Errorf("expected %s to still exist in memories", key)
|
|
}
|
|
}
|
|
}
|
|
if successCount == 0 {
|
|
t.Fatal("expected at least 1 worker to succeed")
|
|
}
|
|
}
|