fix(compact): archive content before destructive compaction; make restore work (#4464)
Content compaction (bd admin compact) overwrote an issue's description and cleared design/notes/acceptance_criteria in place with no archive, while the issue_snapshots/compaction_snapshots tables built to hold that archive were dead code (never written). The only recovery, bd restore, was display-only and relied on a largest-history-row heuristic that dolt gc / history-squash can erase. Net: compaction was effectively irreversible. Wire the existing compaction_snapshots table: archive the full pre-compaction content (snapshot_json BLOB) before the destructive overwrite, aborting if the archive fails; add SnapshotIssue/GetCompactionSnapshot/RestoreFromSnapshot to the CompactionStore interface on both Dolt and embedded stores; and rework bd restore to restore from the snapshot (--apply writes it back; default stays read-only display, with the old Dolt-history reconstruction as fallback). Unit tests assert snapshot-before-overwrite ordering and abort-on-archive- failure; an integration test covers the snapshot -> overwrite -> restore round trip against a real Dolt store. CLI reference docs regenerated for the new flag. Refs #4463 Agent-Signature: claude-opus-4-8-high on behalf of maphew
This commit is contained in:
parent
55914fb08f
commit
889ade6b7f
15 changed files with 507 additions and 51 deletions
|
|
@ -12,17 +12,25 @@ import (
|
|||
"github.com/steveyegge/beads/internal/ui"
|
||||
)
|
||||
|
||||
var restoreApply bool
|
||||
|
||||
var restoreCmd = &cobra.Command{
|
||||
Use: "restore <issue-id>",
|
||||
GroupID: "sync",
|
||||
Short: "Restore full history of a compacted issue from Dolt history",
|
||||
Long: `Restore full history of a compacted issue from Dolt version history.
|
||||
Short: "Restore the pre-compaction content of a compacted issue",
|
||||
Long: `Restore the pre-compaction content of a compacted issue.
|
||||
|
||||
When an issue is compacted, its description and notes are truncated.
|
||||
This command queries Dolt's history tables to find the pre-compaction
|
||||
version and displays the full issue content.
|
||||
When an issue is compacted, its description/design/notes/acceptance criteria
|
||||
are summarized and the originals are archived to a compaction snapshot. This
|
||||
command recovers that original content.
|
||||
|
||||
This is read-only and does not modify the database.`,
|
||||
By default it is read-only: it displays the archived content without modifying
|
||||
the database. Pass --apply to write the original content back into the issue
|
||||
and step its compaction level back down.
|
||||
|
||||
If no archived snapshot exists (e.g. the issue was compacted by an older bd
|
||||
before snapshot archiving), restore falls back to a best-effort reconstruction
|
||||
from Dolt version history, which can only be displayed, not applied.`,
|
||||
Args: cobra.ExactArgs(1),
|
||||
Run: func(cmd *cobra.Command, args []string) {
|
||||
issueID := args[0]
|
||||
|
|
@ -46,6 +54,58 @@ This is read-only and does not modify the database.`,
|
|||
os.Exit(1)
|
||||
}
|
||||
|
||||
// Prefer the archived snapshot: it is the authoritative pre-compaction
|
||||
// copy and the only source that can be safely written back.
|
||||
snap, err := store.GetCompactionSnapshot(ctx, issueID)
|
||||
if err != nil {
|
||||
fmt.Fprintf(os.Stderr, "Error: failed to read compaction snapshot: %v\n", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
if restoreApply {
|
||||
if snap == nil {
|
||||
fmt.Fprintf(os.Stderr, "Error: no archived snapshot for %s; cannot safely restore content\n", issueID)
|
||||
fmt.Fprintf(os.Stderr, "Hint: this issue was compacted before snapshot archiving existed.\n")
|
||||
fmt.Fprintf(os.Stderr, " Run 'bd restore %s' (without --apply) to view the best-effort\n", issueID)
|
||||
fmt.Fprintf(os.Stderr, " version reconstructed from Dolt history.\n")
|
||||
os.Exit(1)
|
||||
}
|
||||
applied, err := store.RestoreFromSnapshot(ctx, issueID)
|
||||
if err != nil {
|
||||
fmt.Fprintf(os.Stderr, "Error: failed to restore issue: %v\n", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
if applied == nil {
|
||||
fmt.Fprintf(os.Stderr, "Error: no archived snapshot for %s\n", issueID)
|
||||
os.Exit(1)
|
||||
}
|
||||
restored, err := store.GetIssue(ctx, issueID)
|
||||
if err != nil {
|
||||
fmt.Fprintf(os.Stderr, "Error: restored, but failed to re-read issue: %v\n", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
if jsonOutput {
|
||||
outputJSON(restored)
|
||||
return
|
||||
}
|
||||
fmt.Printf("%s Restored %s from archived snapshot (compaction level %d → %d)\n",
|
||||
ui.RenderPass("✓"), issueID, issue.CompactionLevel, restored.CompactionLevel)
|
||||
return
|
||||
}
|
||||
|
||||
// Read-only display path. Prefer the archived snapshot; fall back to the
|
||||
// Dolt-history heuristic when no snapshot exists.
|
||||
if snap != nil {
|
||||
view := snapshotView(issue, snap)
|
||||
if jsonOutput {
|
||||
outputJSON(view)
|
||||
} else {
|
||||
displayRestoredIssue(view, "archived snapshot")
|
||||
fmt.Printf("%s\n", ui.RenderMuted("Run 'bd restore "+issueID+" --apply' to write this content back."))
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Query Dolt history for the pre-compaction version
|
||||
history, err := store.History(ctx, issueID)
|
||||
if err != nil {
|
||||
|
|
@ -80,11 +140,29 @@ This is read-only and does not modify the database.`,
|
|||
if jsonOutput {
|
||||
outputJSON(best.Issue)
|
||||
} else {
|
||||
displayRestoredIssue(best.Issue, best.CommitHash)
|
||||
hashDisplay := best.CommitHash
|
||||
if len(hashDisplay) > 8 {
|
||||
hashDisplay = hashDisplay[:8]
|
||||
}
|
||||
displayRestoredIssue(best.Issue, "Dolt commit "+hashDisplay)
|
||||
}
|
||||
},
|
||||
}
|
||||
|
||||
// snapshotView returns a copy of the current issue with its text content
|
||||
// overlaid by the archived pre-compaction snapshot, for read-only display.
|
||||
func snapshotView(issue *types.Issue, snap *types.IssueSnapshot) *types.Issue {
|
||||
view := *issue
|
||||
if snap.Title != "" {
|
||||
view.Title = snap.Title
|
||||
}
|
||||
view.Description = snap.Description
|
||||
view.Design = snap.Design
|
||||
view.Notes = snap.Notes
|
||||
view.AcceptanceCriteria = snap.AcceptanceCriteria
|
||||
return &view
|
||||
}
|
||||
|
||||
// issueContentSize returns the total text content size of an issue.
|
||||
func issueContentSize(issue *types.Issue) int {
|
||||
return len(issue.Description) + len(issue.Design) + len(issue.AcceptanceCriteria) + len(issue.Notes)
|
||||
|
|
@ -92,16 +170,15 @@ func issueContentSize(issue *types.Issue) int {
|
|||
|
||||
func init() {
|
||||
restoreCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output restore results in JSON format")
|
||||
restoreCmd.Flags().BoolVar(&restoreApply, "apply", false, "Write the restored content back into the issue (default: display only)")
|
||||
rootCmd.AddCommand(restoreCmd)
|
||||
}
|
||||
|
||||
// displayRestoredIssue displays the restored issue in a readable format
|
||||
func displayRestoredIssue(issue *types.Issue, commitHash string) {
|
||||
hashDisplay := commitHash
|
||||
if len(hashDisplay) > 8 {
|
||||
hashDisplay = hashDisplay[:8]
|
||||
}
|
||||
fmt.Printf("\n%s %s (restored from Dolt commit %s)\n", ui.RenderAccent("📜"), ui.RenderBold(issue.ID), ui.RenderWarn(hashDisplay))
|
||||
// displayRestoredIssue displays the restored issue in a readable format.
|
||||
// provenance describes where the content came from (e.g. "archived snapshot"
|
||||
// or "Dolt commit abc12345").
|
||||
func displayRestoredIssue(issue *types.Issue, provenance string) {
|
||||
fmt.Printf("\n%s %s (restored from %s)\n", ui.RenderAccent("📜"), ui.RenderBold(issue.ID), ui.RenderWarn(provenance))
|
||||
fmt.Printf("%s\n\n", ui.RenderBold(issue.Title))
|
||||
|
||||
if issue.Description != "" {
|
||||
|
|
|
|||
|
|
@ -104,7 +104,7 @@ Reference for bd Latest. Generated from `bd help --all`.
|
|||
- [bd export](#bd-export) — Export issues to JSONL format
|
||||
- [bd federation](#bd-federation) — Manage peer-to-peer federation (requires CGO)
|
||||
- [bd import](#bd-import) — Import issues from a JSONL file or stdin into the database
|
||||
- [bd restore](#bd-restore) — Restore full history of a compacted issue from Dolt history
|
||||
- [bd restore](#bd-restore) — Restore the pre-compaction content of a compacted issue
|
||||
- [bd vc](#bd-vc) — Version control operations
|
||||
- [bd vc commit](#bd-vc-commit) — Create a commit with all staged changes
|
||||
- [bd vc merge](#bd-vc-merge) — Merge a branch into the current branch
|
||||
|
|
@ -2476,13 +2476,19 @@ bd import [file|-] [flags]
|
|||
|
||||
### bd restore
|
||||
|
||||
Restore full history of a compacted issue from Dolt version history.
|
||||
Restore the pre-compaction content of a compacted issue.
|
||||
|
||||
When an issue is compacted, its description and notes are truncated.
|
||||
This command queries Dolt's history tables to find the pre-compaction
|
||||
version and displays the full issue content.
|
||||
When an issue is compacted, its description/design/notes/acceptance criteria
|
||||
are summarized and the originals are archived to a compaction snapshot. This
|
||||
command recovers that original content.
|
||||
|
||||
This is read-only and does not modify the database.
|
||||
By default it is read-only: it displays the archived content without modifying
|
||||
the database. Pass --apply to write the original content back into the issue
|
||||
and step its compaction level back down.
|
||||
|
||||
If no archived snapshot exists (e.g. the issue was compacted by an older bd
|
||||
before snapshot archiving), restore falls back to a best-effort reconstruction
|
||||
from Dolt version history, which can only be displayed, not applied.
|
||||
|
||||
```
|
||||
bd restore <issue-id> [flags]
|
||||
|
|
@ -2491,7 +2497,8 @@ bd restore <issue-id> [flags]
|
|||
**Flags:**
|
||||
|
||||
```
|
||||
--json Output restore results in JSON format
|
||||
--apply Write the restored content back into the issue (default: display only)
|
||||
--json Output restore results in JSON format
|
||||
```
|
||||
|
||||
### bd vc
|
||||
|
|
|
|||
|
|
@ -35,6 +35,7 @@ type Compactor struct {
|
|||
type compactableStore interface {
|
||||
CheckEligibility(ctx context.Context, issueID string, tier int) (bool, string, error)
|
||||
GetIssue(ctx context.Context, issueID string) (*types.Issue, error)
|
||||
SnapshotIssue(ctx context.Context, issueID string, tier int) error
|
||||
UpdateIssue(ctx context.Context, issueID string, updates map[string]interface{}, actor string) error
|
||||
ApplyCompaction(ctx context.Context, issueID string, tier int, originalSize int, compactedSize int, commitHash string) error
|
||||
AddComment(ctx context.Context, issueID, actor, comment string) error
|
||||
|
|
@ -129,6 +130,13 @@ func (c *Compactor) CompactTier1(ctx context.Context, issueID string) error {
|
|||
return fmt.Errorf("compaction would increase size (%d → %d bytes), keeping original", originalSize, compactedSize)
|
||||
}
|
||||
|
||||
// Archive the original content BEFORE the destructive overwrite, so the
|
||||
// compaction is reversible (bd restore reads this snapshot). If archiving
|
||||
// fails we abort with the original content intact rather than lose it.
|
||||
if err := c.store.SnapshotIssue(ctx, issueID, 1); err != nil {
|
||||
return fmt.Errorf("failed to archive pre-compaction snapshot: %w", err)
|
||||
}
|
||||
|
||||
// Update issue with summarized content
|
||||
updates := map[string]interface{}{
|
||||
"description": summary,
|
||||
|
|
|
|||
|
|
@ -14,6 +14,7 @@ import (
|
|||
type stubStore struct {
|
||||
checkEligibilityFn func(context.Context, string, int) (bool, string, error)
|
||||
getIssueFn func(context.Context, string) (*types.Issue, error)
|
||||
snapshotIssueFn func(context.Context, string, int) error
|
||||
updateIssueFn func(context.Context, string, map[string]interface{}, string) error
|
||||
applyCompactionFn func(context.Context, string, int, int, int, string) error
|
||||
addCommentFn func(context.Context, string, string, string) error
|
||||
|
|
@ -33,6 +34,13 @@ func (s *stubStore) GetIssue(ctx context.Context, issueID string) (*types.Issue,
|
|||
return nil, fmt.Errorf("GetIssue not stubbed")
|
||||
}
|
||||
|
||||
func (s *stubStore) SnapshotIssue(ctx context.Context, issueID string, tier int) error {
|
||||
if s.snapshotIssueFn != nil {
|
||||
return s.snapshotIssueFn(ctx, issueID, tier)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *stubStore) UpdateIssue(ctx context.Context, issueID string, updates map[string]interface{}, actor string) error {
|
||||
if s.updateIssueFn != nil {
|
||||
return s.updateIssueFn(ctx, issueID, updates, actor)
|
||||
|
|
@ -141,6 +149,65 @@ func TestCompactTier1_Success(t *testing.T) {
|
|||
}
|
||||
}
|
||||
|
||||
// TestCompactTier1_SnapshotBeforeOverwrite is the data-safety guard: the
|
||||
// pre-compaction snapshot must be taken BEFORE the destructive UpdateIssue, so
|
||||
// compaction is always reversible.
|
||||
func TestCompactTier1_SnapshotBeforeOverwrite(t *testing.T) {
|
||||
cleanup := withGitHash(t, "deadbeef\n")
|
||||
t.Cleanup(cleanup)
|
||||
|
||||
var order []string
|
||||
store := &stubStore{
|
||||
checkEligibilityFn: func(context.Context, string, int) (bool, string, error) { return true, "", nil },
|
||||
getIssueFn: func(context.Context, string) (*types.Issue, error) { return stubIssue(), nil },
|
||||
snapshotIssueFn: func(ctx context.Context, id string, tier int) error {
|
||||
if tier != 1 {
|
||||
t.Fatalf("expected snapshot tier 1, got %d", tier)
|
||||
}
|
||||
order = append(order, "snapshot")
|
||||
return nil
|
||||
},
|
||||
updateIssueFn: func(context.Context, string, map[string]interface{}, string) error {
|
||||
order = append(order, "update")
|
||||
return nil
|
||||
},
|
||||
}
|
||||
summary := &stubSummarizer{summary: "short"}
|
||||
c := &Compactor{store: store, summarizer: summary, config: &Config{}}
|
||||
|
||||
if err := c.CompactTier1(context.Background(), "bd-123"); err != nil {
|
||||
t.Fatalf("CompactTier1 unexpected error: %v", err)
|
||||
}
|
||||
if len(order) != 2 || order[0] != "snapshot" || order[1] != "update" {
|
||||
t.Fatalf("expected snapshot before update, got %v", order)
|
||||
}
|
||||
}
|
||||
|
||||
// TestCompactTier1_SnapshotError verifies that a failed archive aborts the
|
||||
// compaction so the original content is never overwritten without a snapshot.
|
||||
func TestCompactTier1_SnapshotError(t *testing.T) {
|
||||
updateCalled := false
|
||||
store := &stubStore{
|
||||
checkEligibilityFn: func(context.Context, string, int) (bool, string, error) { return true, "", nil },
|
||||
getIssueFn: func(context.Context, string) (*types.Issue, error) { return stubIssue(), nil },
|
||||
snapshotIssueFn: func(context.Context, string, int) error { return errors.New("disk full") },
|
||||
updateIssueFn: func(context.Context, string, map[string]interface{}, string) error {
|
||||
updateCalled = true
|
||||
return nil
|
||||
},
|
||||
}
|
||||
summary := &stubSummarizer{summary: "short"}
|
||||
c := &Compactor{store: store, summarizer: summary, config: &Config{}}
|
||||
|
||||
err := c.CompactTier1(context.Background(), "bd-123")
|
||||
if err == nil || !strings.Contains(err.Error(), "archive pre-compaction snapshot") {
|
||||
t.Fatalf("expected snapshot error, got %v", err)
|
||||
}
|
||||
if updateCalled {
|
||||
t.Fatalf("issue was overwritten despite snapshot failure")
|
||||
}
|
||||
}
|
||||
|
||||
func TestCompactTier1_Ineligible(t *testing.T) {
|
||||
store := &stubStore{
|
||||
checkEligibilityFn: func(context.Context, string, int) (bool, string, error) { return false, "recently compacted", nil },
|
||||
|
|
|
|||
|
|
@ -12,4 +12,16 @@ type CompactionStore interface {
|
|||
ApplyCompaction(ctx context.Context, issueID string, tier int, originalSize int, compactedSize int, commitHash string) error
|
||||
GetTier1Candidates(ctx context.Context) ([]*types.CompactionCandidate, error)
|
||||
GetTier2Candidates(ctx context.Context) ([]*types.CompactionCandidate, error)
|
||||
|
||||
// SnapshotIssue archives an issue's current text content before a
|
||||
// destructive compaction overwrites it. tier is the level being compacted
|
||||
// to. Must be called before the overwrite.
|
||||
SnapshotIssue(ctx context.Context, issueID string, tier int) error
|
||||
// GetCompactionSnapshot returns the most recent archived snapshot for an
|
||||
// issue, or (nil, nil) when none exists.
|
||||
GetCompactionSnapshot(ctx context.Context, issueID string) (*types.IssueSnapshot, error)
|
||||
// RestoreFromSnapshot restores an issue's content from its most recent
|
||||
// snapshot and steps its compaction level back down. Returns the applied
|
||||
// snapshot, or (nil, nil) when none exists.
|
||||
RestoreFromSnapshot(ctx context.Context, issueID string) (*types.IssueSnapshot, error)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -53,6 +53,38 @@ func (s *DoltStore) ApplyCompaction(ctx context.Context, issueID string, tier in
|
|||
})
|
||||
}
|
||||
|
||||
// SnapshotIssue archives an issue's current text content before a destructive
|
||||
// compaction overwrites it. See issueops.SnapshotIssueInTx.
|
||||
func (s *DoltStore) SnapshotIssue(ctx context.Context, issueID string, tier int) error {
|
||||
return s.withRetryTx(ctx, func(tx *sql.Tx) error {
|
||||
return issueops.SnapshotIssueInTx(ctx, tx, issueID, tier)
|
||||
})
|
||||
}
|
||||
|
||||
// GetCompactionSnapshot returns the most recent archived snapshot for an issue,
|
||||
// or (nil, nil) when none exists.
|
||||
func (s *DoltStore) GetCompactionSnapshot(ctx context.Context, issueID string) (*types.IssueSnapshot, error) {
|
||||
var snap *types.IssueSnapshot
|
||||
err := s.withReadTx(ctx, func(tx *sql.Tx) error {
|
||||
var err error
|
||||
snap, err = issueops.GetLatestSnapshotInTx(ctx, tx, issueID)
|
||||
return err
|
||||
})
|
||||
return snap, err
|
||||
}
|
||||
|
||||
// RestoreFromSnapshot restores an issue's content from its most recent snapshot
|
||||
// and steps its compaction level back down. See issueops.RestoreFromSnapshotInTx.
|
||||
func (s *DoltStore) RestoreFromSnapshot(ctx context.Context, issueID string) (*types.IssueSnapshot, error) {
|
||||
var snap *types.IssueSnapshot
|
||||
err := s.withRetryTx(ctx, func(tx *sql.Tx) error {
|
||||
var err error
|
||||
snap, err = issueops.RestoreFromSnapshotInTx(ctx, tx, issueID)
|
||||
return err
|
||||
})
|
||||
return snap, err
|
||||
}
|
||||
|
||||
// GetTier1Candidates returns issues eligible for tier 1 compaction.
|
||||
func (s *DoltStore) GetTier1Candidates(ctx context.Context) ([]*types.CompactionCandidate, error) {
|
||||
var result []*types.CompactionCandidate
|
||||
|
|
|
|||
|
|
@ -788,3 +788,81 @@ func TestGetTier1Candidates_DependentCount(t *testing.T) {
|
|||
t.Errorf("expected dependent_count 1, got %d", candidates[0].DependentCount)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSnapshotRestoreRoundTrip(t *testing.T) {
|
||||
store, cleanup := setupTestStore(t)
|
||||
defer cleanup()
|
||||
|
||||
ctx, cancel := testContext(t)
|
||||
defer cancel()
|
||||
|
||||
issue := &types.Issue{
|
||||
ID: "snap-rt",
|
||||
Title: "Round Trip",
|
||||
Description: "the original description",
|
||||
Design: "the original design",
|
||||
Notes: "the original notes",
|
||||
AcceptanceCriteria: "the original acceptance criteria",
|
||||
Status: types.StatusOpen,
|
||||
Priority: 2,
|
||||
IssueType: types.TypeTask,
|
||||
}
|
||||
if err := store.CreateIssue(ctx, issue, "tester"); err != nil {
|
||||
t.Fatalf("create issue: %v", err)
|
||||
}
|
||||
|
||||
// No snapshot yet.
|
||||
if snap, err := store.GetCompactionSnapshot(ctx, issue.ID); err != nil || snap != nil {
|
||||
t.Fatalf("expected no snapshot, got snap=%v err=%v", snap, err)
|
||||
}
|
||||
|
||||
// Archive, then simulate the destructive compaction overwrite.
|
||||
if err := store.SnapshotIssue(ctx, issue.ID, 1); err != nil {
|
||||
t.Fatalf("snapshot: %v", err)
|
||||
}
|
||||
updates := map[string]interface{}{
|
||||
"description": "summary", "design": "", "notes": "", "acceptance_criteria": "",
|
||||
}
|
||||
if err := store.UpdateIssue(ctx, issue.ID, updates, "compactor"); err != nil {
|
||||
t.Fatalf("overwrite: %v", err)
|
||||
}
|
||||
if err := store.ApplyCompaction(ctx, issue.ID, 1, 100, 7, "deadbeef"); err != nil {
|
||||
t.Fatalf("apply compaction: %v", err)
|
||||
}
|
||||
|
||||
// Snapshot preserves the originals.
|
||||
snap, err := store.GetCompactionSnapshot(ctx, issue.ID)
|
||||
if err != nil {
|
||||
t.Fatalf("get snapshot: %v", err)
|
||||
}
|
||||
if snap == nil {
|
||||
t.Fatalf("expected snapshot after archiving")
|
||||
}
|
||||
if snap.Description != "the original description" || snap.Design != "the original design" ||
|
||||
snap.Notes != "the original notes" || snap.AcceptanceCriteria != "the original acceptance criteria" {
|
||||
t.Fatalf("snapshot content mismatch: %+v", snap)
|
||||
}
|
||||
if snap.CompactionLevel != 1 {
|
||||
t.Fatalf("expected snapshot level 1, got %d", snap.CompactionLevel)
|
||||
}
|
||||
|
||||
// Restore writes the originals back and clears compaction bookkeeping.
|
||||
applied, err := store.RestoreFromSnapshot(ctx, issue.ID)
|
||||
if err != nil {
|
||||
t.Fatalf("restore: %v", err)
|
||||
}
|
||||
if applied == nil {
|
||||
t.Fatalf("expected restore to apply a snapshot")
|
||||
}
|
||||
got, err := store.GetIssue(ctx, issue.ID)
|
||||
if err != nil {
|
||||
t.Fatalf("get restored issue: %v", err)
|
||||
}
|
||||
if got.Description != "the original description" || got.Design != "the original design" ||
|
||||
got.Notes != "the original notes" || got.AcceptanceCriteria != "the original acceptance criteria" {
|
||||
t.Fatalf("restored content mismatch: %+v", got)
|
||||
}
|
||||
if got.CompactionLevel != 0 {
|
||||
t.Fatalf("expected compaction_level reset to 0, got %d", got.CompactionLevel)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -850,6 +850,32 @@ func (s *EmbeddedDoltStore) ApplyCompaction(ctx context.Context, issueID string,
|
|||
})
|
||||
}
|
||||
|
||||
func (s *EmbeddedDoltStore) SnapshotIssue(ctx context.Context, issueID string, tier int) error {
|
||||
return s.withConn(ctx, true, func(tx *sql.Tx) error {
|
||||
return issueops.SnapshotIssueInTx(ctx, tx, issueID, tier)
|
||||
})
|
||||
}
|
||||
|
||||
func (s *EmbeddedDoltStore) GetCompactionSnapshot(ctx context.Context, issueID string) (*types.IssueSnapshot, error) {
|
||||
var snap *types.IssueSnapshot
|
||||
err := s.withConn(ctx, false, func(tx *sql.Tx) error {
|
||||
var err error
|
||||
snap, err = issueops.GetLatestSnapshotInTx(ctx, tx, issueID)
|
||||
return err
|
||||
})
|
||||
return snap, err
|
||||
}
|
||||
|
||||
func (s *EmbeddedDoltStore) RestoreFromSnapshot(ctx context.Context, issueID string) (*types.IssueSnapshot, error) {
|
||||
var snap *types.IssueSnapshot
|
||||
err := s.withConn(ctx, true, func(tx *sql.Tx) error {
|
||||
var err error
|
||||
snap, err = issueops.RestoreFromSnapshotInTx(ctx, tx, issueID)
|
||||
return err
|
||||
})
|
||||
return snap, err
|
||||
}
|
||||
|
||||
func (s *EmbeddedDoltStore) GetTier1Candidates(ctx context.Context) ([]*types.CompactionCandidate, error) {
|
||||
var result []*types.CompactionCandidate
|
||||
err := s.withConn(ctx, false, func(tx *sql.Tx) error {
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@ package issueops
|
|||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"strconv"
|
||||
"time"
|
||||
|
|
@ -97,6 +98,102 @@ func ApplyCompactionInTx(ctx context.Context, tx *sql.Tx, issueID string, tier i
|
|||
return nil
|
||||
}
|
||||
|
||||
// SnapshotIssueInTx archives an issue's current text content into
|
||||
// compaction_snapshots before a destructive compaction overwrites it. The row
|
||||
// is tagged with the tier the issue is being compacted *to* (so a later restore
|
||||
// of a tier-N issue finds the pre-N content) and is the source of truth for
|
||||
// bd restore. Callers MUST invoke this before clearing/overwriting the fields
|
||||
// so the archive captures the originals.
|
||||
func SnapshotIssueInTx(ctx context.Context, tx *sql.Tx, issueID string, tier int) error {
|
||||
snap := types.IssueSnapshot{CompactionLevel: tier}
|
||||
err := tx.QueryRowContext(ctx,
|
||||
`SELECT title, description, design, notes, acceptance_criteria FROM issues WHERE id = ?`, issueID,
|
||||
).Scan(&snap.Title, &snap.Description, &snap.Design, &snap.Notes, &snap.AcceptanceCriteria)
|
||||
if err == sql.ErrNoRows {
|
||||
return fmt.Errorf("snapshot issue %s: not found", issueID)
|
||||
}
|
||||
if err != nil {
|
||||
return fmt.Errorf("snapshot issue %s: read content: %w", issueID, err)
|
||||
}
|
||||
|
||||
payload, err := json.Marshal(&snap)
|
||||
if err != nil {
|
||||
return fmt.Errorf("snapshot issue %s: marshal: %w", issueID, err)
|
||||
}
|
||||
|
||||
now := time.Now().UTC()
|
||||
if _, err := tx.ExecContext(ctx,
|
||||
`INSERT INTO compaction_snapshots (id, issue_id, compaction_level, snapshot_json, created_at) VALUES (?, ?, ?, ?, ?)`,
|
||||
NewEventID(), issueID, tier, payload, now,
|
||||
); err != nil {
|
||||
return fmt.Errorf("snapshot issue %s: insert: %w", issueID, err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetLatestSnapshotInTx returns the most recent compaction snapshot for an
|
||||
// issue, or (nil, nil) when none exists.
|
||||
func GetLatestSnapshotInTx(ctx context.Context, tx *sql.Tx, issueID string) (*types.IssueSnapshot, error) {
|
||||
var payload []byte
|
||||
var level int
|
||||
err := tx.QueryRowContext(ctx,
|
||||
`SELECT compaction_level, snapshot_json FROM compaction_snapshots WHERE issue_id = ? ORDER BY created_at DESC LIMIT 1`,
|
||||
issueID,
|
||||
).Scan(&level, &payload)
|
||||
if err == sql.ErrNoRows {
|
||||
return nil, nil
|
||||
}
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("get snapshot for %s: %w", issueID, err)
|
||||
}
|
||||
snap := &types.IssueSnapshot{}
|
||||
if err := json.Unmarshal(payload, snap); err != nil {
|
||||
return nil, fmt.Errorf("get snapshot for %s: unmarshal: %w", issueID, err)
|
||||
}
|
||||
snap.CompactionLevel = level
|
||||
return snap, nil
|
||||
}
|
||||
|
||||
// RestoreFromSnapshotInTx restores an issue's text content from its most recent
|
||||
// compaction snapshot and steps its compaction level back down by one. It
|
||||
// returns the snapshot that was applied, or (nil, nil) when no snapshot exists.
|
||||
// The snapshot row is left in place as an audit trail.
|
||||
func RestoreFromSnapshotInTx(ctx context.Context, tx *sql.Tx, issueID string) (*types.IssueSnapshot, error) {
|
||||
snap, err := GetLatestSnapshotInTx(ctx, tx, issueID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if snap == nil {
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
now := time.Now().UTC()
|
||||
newLevel := max(snap.CompactionLevel-1, 0)
|
||||
|
||||
if newLevel == 0 {
|
||||
// Fully restored: clear the compaction bookkeeping so the issue looks
|
||||
// uncompacted again.
|
||||
_, err = tx.ExecContext(ctx, `
|
||||
UPDATE issues
|
||||
SET description = ?, design = ?, notes = ?, acceptance_criteria = ?,
|
||||
compaction_level = 0, compacted_at = NULL, compacted_at_commit = '', original_size = 0,
|
||||
updated_at = ?
|
||||
WHERE id = ?`,
|
||||
snap.Description, snap.Design, snap.Notes, snap.AcceptanceCriteria, now, issueID)
|
||||
} else {
|
||||
_, err = tx.ExecContext(ctx, `
|
||||
UPDATE issues
|
||||
SET description = ?, design = ?, notes = ?, acceptance_criteria = ?,
|
||||
compaction_level = ?, updated_at = ?
|
||||
WHERE id = ?`,
|
||||
snap.Description, snap.Design, snap.Notes, snap.AcceptanceCriteria, newLevel, now, issueID)
|
||||
}
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("restore issue %s: %w", issueID, err)
|
||||
}
|
||||
return snap, nil
|
||||
}
|
||||
|
||||
// GetTier1CandidatesInTx returns issues eligible for tier 1 compaction.
|
||||
func GetTier1CandidatesInTx(ctx context.Context, tx *sql.Tx) ([]*types.CompactionCandidate, error) {
|
||||
days := getCompactDaysInTx(ctx, tx, 1)
|
||||
|
|
|
|||
|
|
@ -14,6 +14,23 @@ type CompactionCandidate struct {
|
|||
DependentCount int
|
||||
}
|
||||
|
||||
// IssueSnapshot is a pre-compaction copy of an issue's mutable text content,
|
||||
// archived (into compaction_snapshots) before compaction destructively
|
||||
// overwrites it. It is the source of truth for `bd restore`. The JSON tags are
|
||||
// the on-disk snapshot_json wire format and must not be renamed: older archived
|
||||
// rows are decoded with these names.
|
||||
type IssueSnapshot struct {
|
||||
// CompactionLevel is the tier the issue was being compacted *to* when this
|
||||
// snapshot was taken, i.e. the level whose pre-compaction content this row
|
||||
// preserves. It is stored in its own column, not in snapshot_json.
|
||||
CompactionLevel int `json:"-"`
|
||||
Title string `json:"title"`
|
||||
Description string `json:"description"`
|
||||
Design string `json:"design"`
|
||||
Notes string `json:"notes"`
|
||||
AcceptanceCriteria string `json:"acceptance_criteria"`
|
||||
}
|
||||
|
||||
// DeleteIssuesResult contains statistics from a batch delete operation.
|
||||
// Used when deleting multiple issues with cascade/force options.
|
||||
type DeleteIssuesResult struct {
|
||||
|
|
|
|||
|
|
@ -10,13 +10,19 @@ Generated from `bd help --doc restore`
|
|||
|
||||
## bd restore
|
||||
|
||||
Restore full history of a compacted issue from Dolt version history.
|
||||
Restore the pre-compaction content of a compacted issue.
|
||||
|
||||
When an issue is compacted, its description and notes are truncated.
|
||||
This command queries Dolt's history tables to find the pre-compaction
|
||||
version and displays the full issue content.
|
||||
When an issue is compacted, its description/design/notes/acceptance criteria
|
||||
are summarized and the originals are archived to a compaction snapshot. This
|
||||
command recovers that original content.
|
||||
|
||||
This is read-only and does not modify the database.
|
||||
By default it is read-only: it displays the archived content without modifying
|
||||
the database. Pass --apply to write the original content back into the issue
|
||||
and step its compaction level back down.
|
||||
|
||||
If no archived snapshot exists (e.g. the issue was compacted by an older bd
|
||||
before snapshot archiving), restore falls back to a best-effort reconstruction
|
||||
from Dolt version history, which can only be displayed, not applied.
|
||||
|
||||
```
|
||||
bd restore <issue-id> [flags]
|
||||
|
|
@ -25,5 +31,6 @@ bd restore <issue-id> [flags]
|
|||
**Flags:**
|
||||
|
||||
```
|
||||
--json Output restore results in JSON format
|
||||
--apply Write the restored content back into the issue (default: display only)
|
||||
--json Output restore results in JSON format
|
||||
```
|
||||
|
|
|
|||
|
|
@ -9063,13 +9063,19 @@ Generated from `bd help --doc restore`
|
|||
|
||||
## bd restore
|
||||
|
||||
Restore full history of a compacted issue from Dolt version history.
|
||||
Restore the pre-compaction content of a compacted issue.
|
||||
|
||||
When an issue is compacted, its description and notes are truncated.
|
||||
This command queries Dolt's history tables to find the pre-compaction
|
||||
version and displays the full issue content.
|
||||
When an issue is compacted, its description/design/notes/acceptance criteria
|
||||
are summarized and the originals are archived to a compaction snapshot. This
|
||||
command recovers that original content.
|
||||
|
||||
This is read-only and does not modify the database.
|
||||
By default it is read-only: it displays the archived content without modifying
|
||||
the database. Pass --apply to write the original content back into the issue
|
||||
and step its compaction level back down.
|
||||
|
||||
If no archived snapshot exists (e.g. the issue was compacted by an older bd
|
||||
before snapshot archiving), restore falls back to a best-effort reconstruction
|
||||
from Dolt version history, which can only be displayed, not applied.
|
||||
|
||||
```
|
||||
bd restore <issue-id> [flags]
|
||||
|
|
@ -9078,7 +9084,8 @@ bd restore <issue-id> [flags]
|
|||
**Flags:**
|
||||
|
||||
```
|
||||
--json Output restore results in JSON format
|
||||
--apply Write the restored content back into the issue (default: display only)
|
||||
--json Output restore results in JSON format
|
||||
```
|
||||
|
||||
</document>
|
||||
|
|
|
|||
|
|
@ -10,13 +10,19 @@ Generated from `bd help --doc restore`
|
|||
|
||||
## bd restore
|
||||
|
||||
Restore full history of a compacted issue from Dolt version history.
|
||||
Restore the pre-compaction content of a compacted issue.
|
||||
|
||||
When an issue is compacted, its description and notes are truncated.
|
||||
This command queries Dolt's history tables to find the pre-compaction
|
||||
version and displays the full issue content.
|
||||
When an issue is compacted, its description/design/notes/acceptance criteria
|
||||
are summarized and the originals are archived to a compaction snapshot. This
|
||||
command recovers that original content.
|
||||
|
||||
This is read-only and does not modify the database.
|
||||
By default it is read-only: it displays the archived content without modifying
|
||||
the database. Pass --apply to write the original content back into the issue
|
||||
and step its compaction level back down.
|
||||
|
||||
If no archived snapshot exists (e.g. the issue was compacted by an older bd
|
||||
before snapshot archiving), restore falls back to a best-effort reconstruction
|
||||
from Dolt version history, which can only be displayed, not applied.
|
||||
|
||||
```
|
||||
bd restore <issue-id> [flags]
|
||||
|
|
@ -25,5 +31,6 @@ bd restore <issue-id> [flags]
|
|||
**Flags:**
|
||||
|
||||
```
|
||||
--json Output restore results in JSON format
|
||||
--apply Write the restored content back into the issue (default: display only)
|
||||
--json Output restore results in JSON format
|
||||
```
|
||||
|
|
|
|||
|
|
@ -10,13 +10,19 @@ Generated from `bd help --doc restore`
|
|||
|
||||
## bd restore
|
||||
|
||||
Restore full history of a compacted issue from Dolt version history.
|
||||
Restore the pre-compaction content of a compacted issue.
|
||||
|
||||
When an issue is compacted, its description and notes are truncated.
|
||||
This command queries Dolt's history tables to find the pre-compaction
|
||||
version and displays the full issue content.
|
||||
When an issue is compacted, its description/design/notes/acceptance criteria
|
||||
are summarized and the originals are archived to a compaction snapshot. This
|
||||
command recovers that original content.
|
||||
|
||||
This is read-only and does not modify the database.
|
||||
By default it is read-only: it displays the archived content without modifying
|
||||
the database. Pass --apply to write the original content back into the issue
|
||||
and step its compaction level back down.
|
||||
|
||||
If no archived snapshot exists (e.g. the issue was compacted by an older bd
|
||||
before snapshot archiving), restore falls back to a best-effort reconstruction
|
||||
from Dolt version history, which can only be displayed, not applied.
|
||||
|
||||
```
|
||||
bd restore <issue-id> [flags]
|
||||
|
|
@ -25,5 +31,6 @@ bd restore <issue-id> [flags]
|
|||
**Flags:**
|
||||
|
||||
```
|
||||
--json Output restore results in JSON format
|
||||
--apply Write the restored content back into the issue (default: display only)
|
||||
--json Output restore results in JSON format
|
||||
```
|
||||
|
|
|
|||
|
|
@ -10,13 +10,19 @@ Generated from `bd help --doc restore`
|
|||
|
||||
## bd restore
|
||||
|
||||
Restore full history of a compacted issue from Dolt version history.
|
||||
Restore the pre-compaction content of a compacted issue.
|
||||
|
||||
When an issue is compacted, its description and notes are truncated.
|
||||
This command queries Dolt's history tables to find the pre-compaction
|
||||
version and displays the full issue content.
|
||||
When an issue is compacted, its description/design/notes/acceptance criteria
|
||||
are summarized and the originals are archived to a compaction snapshot. This
|
||||
command recovers that original content.
|
||||
|
||||
This is read-only and does not modify the database.
|
||||
By default it is read-only: it displays the archived content without modifying
|
||||
the database. Pass --apply to write the original content back into the issue
|
||||
and step its compaction level back down.
|
||||
|
||||
If no archived snapshot exists (e.g. the issue was compacted by an older bd
|
||||
before snapshot archiving), restore falls back to a best-effort reconstruction
|
||||
from Dolt version history, which can only be displayed, not applied.
|
||||
|
||||
```
|
||||
bd restore <issue-id> [flags]
|
||||
|
|
@ -25,5 +31,6 @@ bd restore <issue-id> [flags]
|
|||
**Flags:**
|
||||
|
||||
```
|
||||
--json Output restore results in JSON format
|
||||
--apply Write the restored content back into the issue (default: display only)
|
||||
--json Output restore results in JSON format
|
||||
```
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue