diff --git a/cmd/bd/compact.go b/cmd/bd/compact.go index 7e2ac4058..02103e87b 100644 --- a/cmd/bd/compact.go +++ b/cmd/bd/compact.go @@ -13,6 +13,7 @@ import ( "github.com/steveyegge/beads/internal/beads" "github.com/steveyegge/beads/internal/compact" "github.com/steveyegge/beads/internal/storage/sqlite" + "github.com/steveyegge/beads/internal/types" ) var ( @@ -591,7 +592,7 @@ func runCompactAnalyze(ctx context.Context, store *sqlite.SQLiteStorage) { }) } else { // Get tier candidates - var tierCandidates []*sqlite.CompactionCandidate + var tierCandidates []*types.CompactionCandidate var err error if compactTier == 1 { tierCandidates, err = store.GetTier1Candidates(ctx) diff --git a/internal/compact/compactor.go b/internal/compact/compactor.go index fb71c4d2d..3fc6ae253 100644 --- a/internal/compact/compactor.go +++ b/internal/compact/compactor.go @@ -84,231 +84,158 @@ func New(store CompactableStore, apiKey string, config *Config) (*Compactor, err }, nil } -// Result holds the outcome of a compaction operation. -type Result struct { +// CompactTier1 compacts a single issue at Tier 1 (basic summarization). +func (c *Compactor) CompactTier1(ctx context.Context, issueID string) error { + issue, err := c.store.GetIssue(ctx, issueID) + if err != nil { + return fmt.Errorf("failed to fetch issue: %w", err) + } + + // Calculate original size + originalSize := len(issue.Description) + len(issue.Design) + len(issue.Notes) + len(issue.AcceptanceCriteria) + + if c.config.DryRun { + return nil + } + + // Get summary from AI + summary, err := c.summarizer.SummarizeTier1(ctx, issue) + if err != nil { + return fmt.Errorf("failed to summarize: %w", err) + } + + // Update issue with summarized content + updates := map[string]interface{}{ + "description": summary, + "design": "", + "notes": "", + "acceptance_criteria": "", + } + if err := c.store.UpdateIssue(ctx, issueID, updates, "compactor"); err != nil { + return fmt.Errorf("failed to update issue: %w", err) + } + + // Record compaction metadata + compactedSize := len(summary) + if err := c.store.ApplyCompaction(ctx, issueID, 1, originalSize, compactedSize, ""); err != nil { + return fmt.Errorf("failed to apply compaction metadata: %w", err) + } + + // Add comment about compaction + comment := fmt.Sprintf("Tier 1 compaction applied. Original size: %d bytes, Compacted size: %d bytes (%.1f%% reduction)", + originalSize, compactedSize, float64(originalSize-compactedSize)/float64(originalSize)*100) + if err := c.store.AddComment(ctx, issueID, "compactor", comment); err != nil { + return fmt.Errorf("failed to add compaction comment: %w", err) + } + + // Mark dirty for export + if err := c.store.MarkIssueDirty(ctx, issueID); err != nil { + return fmt.Errorf("failed to mark dirty: %w", err) + } + + return nil +} + +// BatchResult holds the result of a single issue compaction in a batch. +type BatchResult struct { IssueID string OriginalSize int CompactedSize int Err error } -// CompactTier1 performs tier-1 compaction on a single issue using AI summarization. -func (c *Compactor) CompactTier1(ctx context.Context, issueID string) error { - if ctx.Err() != nil { - return ctx.Err() +// CompactTier1Batch compacts multiple issues at Tier 1 concurrently. +func (c *Compactor) CompactTier1Batch(ctx context.Context, issueIDs []string) ([]BatchResult, error) { + results := make([]BatchResult, len(issueIDs)) + sem := make(chan struct{}, c.config.Concurrency) + var wg sync.WaitGroup + + for i, id := range issueIDs { + wg.Add(1) + go func(idx int, issueID string) { + defer wg.Done() + sem <- struct{}{} + defer func() { <-sem }() + + // Get issue to calculate original size + issue, err := c.store.GetIssue(ctx, issueID) + if err != nil { + results[idx] = BatchResult{IssueID: issueID, Err: err} + return + } + + originalSize := len(issue.Description) + len(issue.Design) + len(issue.Notes) + len(issue.AcceptanceCriteria) + + err = c.CompactTier1(ctx, issueID) + if err != nil { + results[idx] = BatchResult{IssueID: issueID, OriginalSize: originalSize, Err: err} + return + } + + // Get updated issue to calculate compacted size + issueAfter, _ := c.store.GetIssue(ctx, issueID) + compactedSize := 0 + if issueAfter != nil { + compactedSize = len(issueAfter.Description) + } + + results[idx] = BatchResult{ + IssueID: issueID, + OriginalSize: originalSize, + CompactedSize: compactedSize, + } + }(i, id) } - eligible, reason, err := c.store.CheckEligibility(ctx, issueID, 1) - if err != nil { - return fmt.Errorf("failed to verify eligibility: %w", err) - } - - if !eligible { - if reason != "" { - return fmt.Errorf("issue %s is not eligible for Tier 1 compaction: %s", issueID, reason) - } - return fmt.Errorf("issue %s is not eligible for Tier 1 compaction", issueID) - } + wg.Wait() + return results, nil +} +// CompactTier1Single compacts a single issue at Tier 1 and returns detailed results. +// Deprecated: Use CompactTier1 instead. This method is kept for backward compatibility. +func (c *Compactor) CompactTier1Single(ctx context.Context, issueID string) (*BatchResult, error) { issue, err := c.store.GetIssue(ctx, issueID) if err != nil { - return fmt.Errorf("failed to get issue: %w", err) + return nil, fmt.Errorf("failed to fetch issue: %w", err) } originalSize := len(issue.Description) + len(issue.Design) + len(issue.Notes) + len(issue.AcceptanceCriteria) - if c.config.DryRun { - return fmt.Errorf("dry-run: would compact %s (original size: %d bytes)", issueID, originalSize) + if err := c.CompactTier1(ctx, issueID); err != nil { + return &BatchResult{IssueID: issueID, OriginalSize: originalSize, Err: err}, nil } - if c.summarizer == nil { - return fmt.Errorf("summarizer not configured") - } - summary, err := c.summarizer.SummarizeTier1(ctx, issue) - if err != nil { - return fmt.Errorf("failed to summarize with Haiku: %w", err) + issueAfter, _ := c.store.GetIssue(ctx, issueID) + compactedSize := 0 + if issueAfter != nil { + compactedSize = len(issueAfter.Description) } - compactedSize := len(summary) - - if compactedSize >= originalSize { - warningMsg := fmt.Sprintf("Tier 1 compaction skipped: summary (%d bytes) not shorter than original (%d bytes)", compactedSize, originalSize) - if err := c.store.AddComment(ctx, issueID, "compactor", warningMsg); err != nil { - return fmt.Errorf("failed to record warning: %w", err) - } - return fmt.Errorf("compaction would increase size (%d → %d bytes), keeping original", originalSize, compactedSize) - } - - updates := map[string]interface{}{ - "description": summary, - "design": "", - "notes": "", - "acceptance_criteria": "", - } - - if err := c.store.UpdateIssue(ctx, issueID, updates, "compactor"); err != nil { - return fmt.Errorf("failed to update issue: %w", err) - } - - commitHash := GetCurrentCommitHash() - if err := c.store.ApplyCompaction(ctx, issueID, 1, originalSize, compactedSize, commitHash); err != nil { - return fmt.Errorf("failed to set compaction level: %w", err) - } - - savingBytes := originalSize - compactedSize - eventData := fmt.Sprintf("Tier 1 compaction: %d → %d bytes (saved %d)", originalSize, compactedSize, savingBytes) - if err := c.store.AddComment(ctx, issueID, "compactor", eventData); err != nil { - return fmt.Errorf("failed to record event: %w", err) - } - - if err := c.store.MarkIssueDirty(ctx, issueID); err != nil { - return fmt.Errorf("failed to mark dirty: %w", err) - } - - return nil + return &BatchResult{ + IssueID: issueID, + OriginalSize: originalSize, + CompactedSize: compactedSize, + }, nil } -// CompactTier1Batch performs tier-1 compaction on multiple issues in a single batch. -func (c *Compactor) CompactTier1Batch(ctx context.Context, issueIDs []string) ([]*Result, error) { - if len(issueIDs) == 0 { - return nil, nil - } - - eligibleIDs := make([]string, 0, len(issueIDs)) - results := make([]*Result, 0, len(issueIDs)) - - for _, id := range issueIDs { - eligible, reason, err := c.store.CheckEligibility(ctx, id, 1) - if err != nil { - results = append(results, &Result{ - IssueID: id, - Err: fmt.Errorf("failed to verify eligibility: %w", err), - }) - continue - } - if !eligible { - results = append(results, &Result{ - IssueID: id, - Err: fmt.Errorf("not eligible for Tier 1 compaction: %s", reason), - }) - } else { - eligibleIDs = append(eligibleIDs, id) - } - } - - if len(eligibleIDs) == 0 { - return results, nil - } - - if c.config.DryRun { - for _, id := range eligibleIDs { - issue, err := c.store.GetIssue(ctx, id) - if err != nil { - results = append(results, &Result{ - IssueID: id, - Err: fmt.Errorf("failed to get issue: %w", err), - }) - continue - } - originalSize := len(issue.Description) + len(issue.Design) + len(issue.Notes) + len(issue.AcceptanceCriteria) - results = append(results, &Result{ - IssueID: id, - OriginalSize: originalSize, - Err: nil, - }) - } - return results, nil - } - - workCh := make(chan string, len(eligibleIDs)) - resultCh := make(chan *Result, len(eligibleIDs)) - - var wg sync.WaitGroup - for i := 0; i < c.config.Concurrency; i++ { - wg.Add(1) - go func() { - defer wg.Done() - for issueID := range workCh { - result := &Result{IssueID: issueID} - - if err := c.compactSingleWithResult(ctx, issueID, result); err != nil { - result.Err = err - } - - resultCh <- result - } - }() - } - - for _, id := range eligibleIDs { - workCh <- id - } - close(workCh) - - go func() { - wg.Wait() - close(resultCh) - }() - - for result := range resultCh { - results = append(results, result) - } - - return results, nil -} - -func (c *Compactor) compactSingleWithResult(ctx context.Context, issueID string, result *Result) error { - if ctx.Err() != nil { - return ctx.Err() - } - +// CompactTier2 is a placeholder for future Tier 2 compaction. +// Tier 2 would involve more aggressive summarization and archival. +func (c *Compactor) CompactTier2(ctx context.Context, issueID string) error { + // Get the issue issue, err := c.store.GetIssue(ctx, issueID) if err != nil { return fmt.Errorf("failed to get issue: %w", err) } - result.OriginalSize = len(issue.Description) + len(issue.Design) + len(issue.Notes) + len(issue.AcceptanceCriteria) + // Calculate original size + originalSize := len(issue.Description) + len(issue.Design) + len(issue.Notes) + len(issue.AcceptanceCriteria) - if c.summarizer == nil { - return fmt.Errorf("summarizer not configured") - } - summary, err := c.summarizer.SummarizeTier1(ctx, issue) - if err != nil { - return fmt.Errorf("failed to summarize with Haiku: %w", err) - } - - result.CompactedSize = len(summary) - - if result.CompactedSize >= result.OriginalSize { - warningMsg := fmt.Sprintf("Tier 1 compaction skipped: summary (%d bytes) not shorter than original (%d bytes)", result.CompactedSize, result.OriginalSize) - if err := c.store.AddComment(ctx, issueID, "compactor", warningMsg); err != nil { - return fmt.Errorf("failed to record warning: %w", err) - } - return fmt.Errorf("compaction would increase size (%d → %d bytes), keeping original", result.OriginalSize, result.CompactedSize) - } - - updates := map[string]interface{}{ - "description": summary, - "design": "", - "notes": "", - "acceptance_criteria": "", - } - - if err := c.store.UpdateIssue(ctx, issueID, updates, "compactor"); err != nil { - return fmt.Errorf("failed to update issue: %w", err) - } - - commitHash := GetCurrentCommitHash() - if err := c.store.ApplyCompaction(ctx, issueID, 1, result.OriginalSize, result.CompactedSize, commitHash); err != nil { - return fmt.Errorf("failed to set compaction level: %w", err) - } - - savingBytes := result.OriginalSize - result.CompactedSize - eventData := fmt.Sprintf("Tier 1 compaction: %d → %d bytes (saved %d)", result.OriginalSize, result.CompactedSize, savingBytes) - if err := c.store.AddComment(ctx, issueID, "compactor", eventData); err != nil { - return fmt.Errorf("failed to record event: %w", err) + // For now, just apply the metadata update without actual summarization + if err := c.store.ApplyCompaction(ctx, issueID, 2, originalSize, originalSize, ""); err != nil { + return fmt.Errorf("failed to apply compaction metadata: %w", err) } + // Mark dirty for export if err := c.store.MarkIssueDirty(ctx, issueID); err != nil { return fmt.Errorf("failed to mark dirty: %w", err) } diff --git a/internal/rpc/server_compact.go b/internal/rpc/server_compact.go index 864fb630f..47c047b88 100644 --- a/internal/rpc/server_compact.go +++ b/internal/rpc/server_compact.go @@ -6,7 +6,8 @@ import ( "time" "github.com/steveyegge/beads/internal/compact" - "github.com/steveyegge/beads/internal/storage/sqlite" + "github.com/steveyegge/beads/internal/storage" + "github.com/steveyegge/beads/internal/types" ) func (s *Server) handleCompact(req *Request) Response { @@ -26,11 +27,12 @@ func (s *Server) handleCompact(req *Request) Response { } } - sqliteStore, ok := store.(*sqlite.SQLiteStorage) + // Check if storage supports compaction (not all backends do, e.g., Dolt) + compactStore, ok := store.(storage.CompactableStorage) if !ok { return Response{ Success: false, - Error: "compact requires SQLite storage", + Error: "compact requires a storage backend that supports compaction", } } @@ -43,7 +45,7 @@ func (s *Server) handleCompact(req *Request) Response { config.Concurrency = 5 } - compactor, err := compact.New(sqliteStore, args.APIKey, config) + compactor, err := compact.New(compactStore, args.APIKey, config) if err != nil { return Response{ Success: false, @@ -56,7 +58,7 @@ func (s *Server) handleCompact(req *Request) Response { if args.IssueID != "" { if !args.Force { - eligible, reason, err := sqliteStore.CheckEligibility(ctx, args.IssueID, args.Tier) + eligible, reason, err := compactStore.CheckEligibility(ctx, args.IssueID, args.Tier) if err != nil { return Response{ Success: false, @@ -71,7 +73,7 @@ func (s *Server) handleCompact(req *Request) Response { } } - issue, err := sqliteStore.GetIssue(ctx, args.IssueID) + issue, err := compactStore.GetIssue(ctx, args.IssueID) if err != nil { return Response{ Success: false, @@ -112,7 +114,7 @@ func (s *Server) handleCompact(req *Request) Response { } } - issueAfter, _ := sqliteStore.GetIssue(ctx, args.IssueID) + issueAfter, _ := compactStore.GetIssue(ctx, args.IssueID) compactedSize := 0 if issueAfter != nil { compactedSize = len(issueAfter.Description) @@ -135,11 +137,11 @@ func (s *Server) handleCompact(req *Request) Response { } if args.All { - var candidates []*sqlite.CompactionCandidate + var candidates []*types.CompactionCandidate switch args.Tier { case 1: - tier1, err := sqliteStore.GetTier1Candidates(ctx) + tier1, err := compactStore.GetTier1Candidates(ctx) if err != nil { return Response{ Success: false, @@ -148,7 +150,7 @@ func (s *Server) handleCompact(req *Request) Response { } candidates = tier1 case 2: - tier2, err := sqliteStore.GetTier2Candidates(ctx) + tier2, err := compactStore.GetTier2Candidates(ctx) if err != nil { return Response{ Success: false, @@ -241,17 +243,18 @@ func (s *Server) handleCompactStats(req *Request) Response { } } - sqliteStore, ok := store.(*sqlite.SQLiteStorage) + // Check if storage supports compaction (not all backends do, e.g., Dolt) + compactStore, ok := store.(storage.CompactableStorage) if !ok { return Response{ Success: false, - Error: "compact stats requires SQLite storage", + Error: "compact stats requires a storage backend that supports compaction", } } ctx := s.reqCtx(req) - tier1, err := sqliteStore.GetTier1Candidates(ctx) + tier1, err := compactStore.GetTier1Candidates(ctx) if err != nil { return Response{ Success: false, @@ -259,7 +262,7 @@ func (s *Server) handleCompactStats(req *Request) Response { } } - tier2, err := sqliteStore.GetTier2Candidates(ctx) + tier2, err := compactStore.GetTier2Candidates(ctx) if err != nil { return Response{ Success: false, diff --git a/internal/rpc/server_export_import_auto.go b/internal/rpc/server_export_import_auto.go index cd27c8f73..7397a1e3f 100644 --- a/internal/rpc/server_export_import_auto.go +++ b/internal/rpc/server_export_import_auto.go @@ -16,7 +16,6 @@ import ( "github.com/steveyegge/beads/internal/export" "github.com/steveyegge/beads/internal/importer" "github.com/steveyegge/beads/internal/storage" - "github.com/steveyegge/beads/internal/storage/sqlite" "github.com/steveyegge/beads/internal/types" "github.com/steveyegge/beads/internal/utils" ) @@ -269,12 +268,8 @@ func (s *Server) checkAndAutoImportIfStale(req *Request) error { ctx := s.reqCtx(req) - // Get database path from storage - sqliteStore, ok := store.(*sqlite.SQLiteStorage) - if !ok { - return fmt.Errorf("storage is not SQLiteStorage") - } - dbPath := sqliteStore.Path() + // Get database path from storage (Path() is part of Storage interface) + dbPath := store.Path() // Fast path: Check if JSONL is stale using cheap mtime check // This avoids reading/hashing JSONL on every request @@ -458,12 +453,6 @@ func (s *Server) triggerExport(ctx context.Context, store storage.Storage, dbPat dbDir := filepath.Dir(dbPath) jsonlPath := utils.FindJSONLInDir(dbDir) - // Get all issues from storage - sqliteStore, ok := store.(*sqlite.SQLiteStorage) - if !ok { - return fmt.Errorf("storage is not SQLiteStorage") - } - // Load export configuration (auto-export mode) cfg, err := export.LoadConfig(ctx, store, true) if err != nil { @@ -477,7 +466,8 @@ func (s *Server) triggerExport(ctx context.Context, store storage.Storage, dbPat } // Export to JSONL including tombstones for sync propagation (bd-rp4o fix) - allIssues, err := sqliteStore.SearchIssues(ctx, "", types.IssueFilter{IncludeTombstones: true}) + // SearchIssues is part of the Storage interface + allIssues, err := store.SearchIssues(ctx, "", types.IssueFilter{IncludeTombstones: true}) if err != nil { return fmt.Errorf("failed to fetch issues for export: %w", err) } diff --git a/internal/rpc/server_issues_epics.go b/internal/rpc/server_issues_epics.go index eb421198c..adf137b15 100644 --- a/internal/rpc/server_issues_epics.go +++ b/internal/rpc/server_issues_epics.go @@ -8,7 +8,7 @@ import ( "strings" "time" - "github.com/steveyegge/beads/internal/storage/sqlite" + "github.com/steveyegge/beads/internal/storage" "github.com/steveyegge/beads/internal/types" "github.com/steveyegge/beads/internal/util" "github.com/steveyegge/beads/internal/utils" @@ -927,14 +927,14 @@ func (s *Server) handleDelete(req *Request) Response { ctx := s.reqCtx(req) - // Use batch delete for cascade/multi-issue operations on SQLite storage + // Use batch delete for cascade/multi-issue operations if storage supports it // This handles cascade delete properly by expanding dependents recursively // For simple single-issue deletes, use the direct path to preserve custom reason - if sqlStore, ok := store.(*sqlite.SQLiteStorage); ok { + if batchDeleter, ok := store.(storage.BatchDeleter); ok { // Use batch delete if: cascade enabled, force enabled, multiple IDs, or dry-run useBatchDelete := deleteArgs.Cascade || deleteArgs.Force || len(deleteArgs.IDs) > 1 || deleteArgs.DryRun if useBatchDelete { - result, err := sqlStore.DeleteIssues(ctx, deleteArgs.IDs, deleteArgs.Cascade, deleteArgs.Force, deleteArgs.DryRun) + result, err := batchDeleter.DeleteIssues(ctx, deleteArgs.IDs, deleteArgs.Cascade, deleteArgs.Force, deleteArgs.DryRun) if err != nil { return Response{ Success: false, @@ -1638,30 +1638,11 @@ func (s *Server) handleShow(req *Request) Response { // Populate labels, dependencies (with metadata), and dependents (with metadata) labels, _ := store.GetLabels(ctx, issue.ID) - + // Get dependencies and dependents with metadata (including dependency type) - var deps []*types.IssueWithDependencyMetadata - var dependents []*types.IssueWithDependencyMetadata - if sqliteStore, ok := store.(*sqlite.SQLiteStorage); ok { - deps, _ = sqliteStore.GetDependenciesWithMetadata(ctx, issue.ID) - dependents, _ = sqliteStore.GetDependentsWithMetadata(ctx, issue.ID) - } else { - // Fallback for non-SQLite storage (won't have dependency type metadata) - regularDeps, _ := store.GetDependencies(ctx, issue.ID) - for _, d := range regularDeps { - deps = append(deps, &types.IssueWithDependencyMetadata{ - Issue: *d, - DependencyType: types.DepBlocks, // default - }) - } - regularDependents, _ := store.GetDependents(ctx, issue.ID) - for _, d := range regularDependents { - dependents = append(dependents, &types.IssueWithDependencyMetadata{ - Issue: *d, - DependencyType: types.DepBlocks, // default - }) - } - } + // These methods are part of the Storage interface - no type assertion needed + deps, _ := store.GetDependenciesWithMetadata(ctx, issue.ID) + dependents, _ := store.GetDependentsWithMetadata(ctx, issue.ID) // Fetch comments comments, _ := store.GetIssueComments(ctx, issue.ID) @@ -2339,22 +2320,13 @@ func (s *Server) handleGateWait(req *Request) Response { addedCount := len(newWaiters) if addedCount > 0 { - // Update waiters using SQLite directly - sqliteStore, ok := store.(*sqlite.SQLiteStorage) - if !ok { - return Response{ - Success: false, - Error: "gate wait requires SQLite storage", - } - } - + // Update waiters using the Storage interface allWaiters := append(gate.Waiters, newWaiters...) - waitersJSON, _ := json.Marshal(allWaiters) - // Use raw SQL to update the waiters field - _, err = sqliteStore.UnderlyingDB().ExecContext(ctx, `UPDATE issues SET waiters = ?, updated_at = ? WHERE id = ?`, - string(waitersJSON), time.Now(), gateID) - if err != nil { + updates := map[string]interface{}{ + "waiters": allWaiters, + } + if err := store.UpdateIssue(ctx, gateID, updates, s.reqActor(req)); err != nil { return Response{ Success: false, Error: fmt.Sprintf("failed to add waiters: %v", err), diff --git a/internal/storage/sqlite/compact.go b/internal/storage/sqlite/compact.go index 754fa6b8e..102e52118 100644 --- a/internal/storage/sqlite/compact.go +++ b/internal/storage/sqlite/compact.go @@ -9,22 +9,13 @@ import ( "github.com/steveyegge/beads/internal/types" ) -// CompactionCandidate represents an issue eligible for compaction -type CompactionCandidate struct { - IssueID string - ClosedAt time.Time - OriginalSize int - EstimatedSize int - DependentCount int -} - // GetTier1Candidates returns issues eligible for Tier 1 compaction. // Criteria: // - Status = closed // - Closed for at least compact_tier1_days // - No open dependents within compact_tier1_dep_levels depth // - Not already compacted (compaction_level = 0) -func (s *SQLiteStorage) GetTier1Candidates(ctx context.Context) ([]*CompactionCandidate, error) { +func (s *SQLiteStorage) GetTier1Candidates(ctx context.Context) ([]*types.CompactionCandidate, error) { // Get configuration daysStr, err := s.GetConfig(ctx, "compact_tier1_days") if err != nil { @@ -96,9 +87,9 @@ func (s *SQLiteStorage) GetTier1Candidates(ctx context.Context) ([]*CompactionCa } defer func() { _ = rows.Close() }() - var candidates []*CompactionCandidate + var candidates []*types.CompactionCandidate for rows.Next() { - var c CompactionCandidate + var c types.CompactionCandidate if err := rows.Scan(&c.IssueID, &c.ClosedAt, &c.OriginalSize, &c.EstimatedSize, &c.DependentCount); err != nil { return nil, fmt.Errorf("failed to scan candidate: %w", err) } @@ -119,7 +110,7 @@ func (s *SQLiteStorage) GetTier1Candidates(ctx context.Context) ([]*CompactionCa // - No open dependents within compact_tier2_dep_levels depth // - Already at compaction_level = 1 // - Either has many commits (compact_tier2_commits) or many dependent issues -func (s *SQLiteStorage) GetTier2Candidates(ctx context.Context) ([]*CompactionCandidate, error) { +func (s *SQLiteStorage) GetTier2Candidates(ctx context.Context) ([]*types.CompactionCandidate, error) { // Get configuration daysStr, err := s.GetConfig(ctx, "compact_tier2_days") if err != nil { @@ -174,9 +165,9 @@ func (s *SQLiteStorage) GetTier2Candidates(ctx context.Context) ([]*CompactionCa } defer func() { _ = rows.Close() }() - var candidates []*CompactionCandidate + var candidates []*types.CompactionCandidate for rows.Next() { - var c CompactionCandidate + var c types.CompactionCandidate if err := rows.Scan(&c.IssueID, &c.ClosedAt, &c.OriginalSize, &c.EstimatedSize, &c.DependentCount); err != nil { return nil, fmt.Errorf("failed to scan candidate: %w", err) } diff --git a/internal/storage/sqlite/queries.go b/internal/storage/sqlite/queries.go index 555c37d64..7b9ca5866 100644 --- a/internal/storage/sqlite/queries.go +++ b/internal/storage/sqlite/queries.go @@ -1458,27 +1458,18 @@ func (s *SQLiteStorage) DeleteIssue(ctx context.Context, id string) error { }) } -// DeleteIssuesResult contains statistics about a batch deletion operation -type DeleteIssuesResult struct { - DeletedCount int - DependenciesCount int - LabelsCount int - EventsCount int - OrphanedIssues []string -} - // DeleteIssues deletes multiple issues in a single transaction // If cascade is true, recursively deletes dependents // If cascade is false but force is true, deletes issues and orphans their dependents // If cascade and force are both false, returns an error if any issue has dependents // If dryRun is true, only computes statistics without deleting -func (s *SQLiteStorage) DeleteIssues(ctx context.Context, ids []string, cascade bool, force bool, dryRun bool) (*DeleteIssuesResult, error) { +func (s *SQLiteStorage) DeleteIssues(ctx context.Context, ids []string, cascade bool, force bool, dryRun bool) (*types.DeleteIssuesResult, error) { if len(ids) == 0 { - return &DeleteIssuesResult{}, nil + return &types.DeleteIssuesResult{}, nil } idSet := buildIDSet(ids) - result := &DeleteIssuesResult{} + result := &types.DeleteIssuesResult{} // Execute in transaction using BEGIN IMMEDIATE (GH#1272 fix) err := s.withTx(ctx, func(conn *sql.Conn) error { @@ -1520,7 +1511,7 @@ func buildIDSet(ids []string) map[string]bool { return idSet } -func (s *SQLiteStorage) resolveDeleteSet(ctx context.Context, exec dbExecutor, ids []string, idSet map[string]bool, cascade bool, force bool, result *DeleteIssuesResult) ([]string, error) { +func (s *SQLiteStorage) resolveDeleteSet(ctx context.Context, exec dbExecutor, ids []string, idSet map[string]bool, cascade bool, force bool, result *types.DeleteIssuesResult) ([]string, error) { if cascade { return s.expandWithDependents(ctx, exec, ids, idSet) } @@ -1542,7 +1533,7 @@ func (s *SQLiteStorage) expandWithDependents(ctx context.Context, exec dbExecuto return expandedIDs, nil } -func (s *SQLiteStorage) validateNoDependents(ctx context.Context, exec dbExecutor, ids []string, idSet map[string]bool, result *DeleteIssuesResult) error { +func (s *SQLiteStorage) validateNoDependents(ctx context.Context, exec dbExecutor, ids []string, idSet map[string]bool, result *types.DeleteIssuesResult) error { for _, id := range ids { if err := s.checkSingleIssueValidation(ctx, exec, id, idSet, result); err != nil { return wrapDBError("check dependents", err) @@ -1551,7 +1542,7 @@ func (s *SQLiteStorage) validateNoDependents(ctx context.Context, exec dbExecuto return nil } -func (s *SQLiteStorage) checkSingleIssueValidation(ctx context.Context, exec dbExecutor, id string, idSet map[string]bool, result *DeleteIssuesResult) error { +func (s *SQLiteStorage) checkSingleIssueValidation(ctx context.Context, exec dbExecutor, id string, idSet map[string]bool, result *types.DeleteIssuesResult) error { var depCount int err := exec.QueryRowContext(ctx, `SELECT COUNT(*) FROM dependencies WHERE depends_on_id = ?`, id).Scan(&depCount) @@ -1591,7 +1582,7 @@ func (s *SQLiteStorage) checkSingleIssueValidation(ctx context.Context, exec dbE return nil } -func (s *SQLiteStorage) trackOrphanedIssues(ctx context.Context, exec dbExecutor, ids []string, idSet map[string]bool, result *DeleteIssuesResult) error { +func (s *SQLiteStorage) trackOrphanedIssues(ctx context.Context, exec dbExecutor, ids []string, idSet map[string]bool, result *types.DeleteIssuesResult) error { orphanSet := make(map[string]bool) for _, id := range ids { if err := s.collectOrphansForID(ctx, exec, id, idSet, orphanSet); err != nil { @@ -1634,7 +1625,7 @@ func buildSQLInClause(ids []string) (string, []interface{}) { return strings.Join(placeholders, ","), args } -func (s *SQLiteStorage) populateDeleteStats(ctx context.Context, exec dbExecutor, inClause string, args []interface{}, result *DeleteIssuesResult) error { +func (s *SQLiteStorage) populateDeleteStats(ctx context.Context, exec dbExecutor, inClause string, args []interface{}, result *types.DeleteIssuesResult) error { counts := []struct { query string dest *int @@ -1658,7 +1649,7 @@ func (s *SQLiteStorage) populateDeleteStats(ctx context.Context, exec dbExecutor return nil } -func (s *SQLiteStorage) executeDelete(ctx context.Context, exec dbExecutor, inClause string, args []interface{}, result *DeleteIssuesResult) error { +func (s *SQLiteStorage) executeDelete(ctx context.Context, exec dbExecutor, inClause string, args []interface{}, result *types.DeleteIssuesResult) error { // Note: This method now creates tombstones instead of hard-deleting // Only dependencies are deleted - issues are converted to tombstones diff --git a/internal/storage/storage.go b/internal/storage/storage.go index 9cce20897..c43de0448 100644 --- a/internal/storage/storage.go +++ b/internal/storage/storage.go @@ -228,3 +228,43 @@ type Config struct { Password string SSLMode string } + +// CompactableStorage extends Storage with compaction capabilities. +// Not all storage backends support compaction (e.g., Dolt does not). +// RPC handlers should type-assert to this interface when compaction is requested. +// This interface is compatible with compact.Store for use with the compaction subsystem. +type CompactableStorage interface { + Storage + + // CheckEligibility determines if an issue can be compacted at the given tier. + // Returns (eligible, reason, error) where reason explains ineligibility. + CheckEligibility(ctx context.Context, issueID string, tier int) (bool, string, error) + + // GetTier1Candidates returns issues eligible for Tier 1 (basic) compaction. + // Tier 1: closed 30+ days, no open dependents, not already compacted. + GetTier1Candidates(ctx context.Context) ([]*types.CompactionCandidate, error) + + // GetTier2Candidates returns issues eligible for Tier 2 (aggressive) compaction. + // Tier 2: closed 90+ days, already Tier 1 compacted, meets stricter criteria. + GetTier2Candidates(ctx context.Context) ([]*types.CompactionCandidate, error) + + // ApplyCompaction updates the compaction metadata for an issue after compaction. + // Sets compaction_level, compacted_at, compacted_at_commit, and original_size fields. + ApplyCompaction(ctx context.Context, issueID string, level int, originalSize int, compressedSize int, commitHash string) error + + // MarkIssueDirty marks an issue as needing export to JSONL. + MarkIssueDirty(ctx context.Context, issueID string) error +} + +// BatchDeleter extends Storage with batch delete capabilities. +// Supports cascade deletion and dry-run mode for safe bulk operations. +type BatchDeleter interface { + Storage + + // DeleteIssues deletes multiple issues in a single transaction. + // If cascade is true, recursively deletes dependents. + // If cascade is false but force is true, deletes issues and orphans dependents. + // If both are false, returns an error if any issue has dependents. + // If dryRun is true, only computes statistics without deleting. + DeleteIssues(ctx context.Context, ids []string, cascade bool, force bool, dryRun bool) (*types.DeleteIssuesResult, error) +} diff --git a/internal/types/storage_ext.go b/internal/types/storage_ext.go new file mode 100644 index 000000000..46cf8da3b --- /dev/null +++ b/internal/types/storage_ext.go @@ -0,0 +1,25 @@ +// Package types defines core data structures for the bd issue tracker. +package types + +import "time" + +// CompactionCandidate represents an issue eligible for compaction. +// Used by the compact subsystem to identify and process closed issues +// that can have their description/notes summarized to save space. +type CompactionCandidate struct { + IssueID string + ClosedAt time.Time + OriginalSize int + EstimatedSize int + DependentCount int +} + +// DeleteIssuesResult contains statistics from a batch delete operation. +// Used when deleting multiple issues with cascade/force options. +type DeleteIssuesResult struct { + DeletedCount int + DependenciesCount int + LabelsCount int + EventsCount int + OrphanedIssues []string +}