beads/internal/compact/compactor.go
collins 9c96517d01 test(compact): improve internal/compact coverage from 54.9% to 87.9%
Add comprehensive unit tests for New constructor, CompactTier1 error
paths, CompactTier1Single, CompactTier2, and SummarizeTier1 with audit.
Fix nil pointer dereference in New when API key is missing (typed nil
*HaikuClient assigned to summarizer interface caused panic in type
assertion).

Closes bd-thgk

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-05 18:41:47 -08:00

270 lines
8.2 KiB
Go

package compact
import (
"context"
"errors"
"fmt"
"sync"
"github.com/steveyegge/beads/internal/types"
)
const (
defaultConcurrency = 5
)
// Config holds configuration for the compaction process.
type Config struct {
APIKey string
Concurrency int
DryRun bool
AuditEnabled bool
Actor string
}
// Compactor handles issue compaction using AI summarization.
type Compactor struct {
store CompactableStore
summarizer summarizer
config *Config
}
// CompactableStore defines the storage interface required for compaction.
// This interface can be implemented by any storage backend (SQLite, Dolt, etc.)
// that wants to support the compaction feature.
type CompactableStore interface {
CheckEligibility(ctx context.Context, issueID string, tier int) (bool, string, error)
GetIssue(ctx context.Context, issueID string) (*types.Issue, 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
MarkIssueDirty(ctx context.Context, issueID string) error
}
type summarizer interface {
SummarizeTier1(ctx context.Context, issue *types.Issue) (string, error)
}
// New creates a new Compactor instance with the given configuration.
// The store parameter must implement CompactableStore interface.
func New(store CompactableStore, apiKey string, config *Config) (*Compactor, error) {
if config == nil {
config = &Config{
Concurrency: defaultConcurrency,
}
}
if config.Concurrency <= 0 {
config.Concurrency = defaultConcurrency
}
if apiKey != "" {
config.APIKey = apiKey
}
var haikuClient summarizer
var err error
if !config.DryRun {
haikuClient, err = NewHaikuClient(config.APIKey)
if err != nil {
if errors.Is(err, ErrAPIKeyRequired) {
config.DryRun = true
} else {
return nil, fmt.Errorf("failed to create Haiku client: %w", err)
}
}
}
if hc, ok := haikuClient.(*HaikuClient); ok && hc != nil {
hc.auditEnabled = config.AuditEnabled
hc.auditActor = config.Actor
}
return &Compactor{
store: store,
summarizer: haikuClient,
config: config,
}, nil
}
// CompactTier1 compacts a single issue at Tier 1 (basic summarization).
func (c *Compactor) CompactTier1(ctx context.Context, issueID string) error {
if ctx.Err() != nil {
return ctx.Err()
}
// Check eligibility before fetching issue (fail fast)
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)
}
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 fmt.Errorf("dry-run: would compact %s (original size: %d bytes)", issueID, originalSize)
}
// Get summary from AI
summary, err := c.summarizer.SummarizeTier1(ctx, issue)
if err != nil {
return fmt.Errorf("failed to summarize: %w", err)
}
// Check if compaction would actually reduce size
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)
}
// 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 with git commit hash
commitHash := GetCurrentCommitHash()
if err := c.store.ApplyCompaction(ctx, issueID, 1, originalSize, compactedSize, commitHash); err != nil {
return fmt.Errorf("failed to apply compaction metadata: %w", err)
}
// Add comment about compaction
savingBytes := originalSize - compactedSize
comment := fmt.Sprintf("Tier 1 compaction: %d → %d bytes (saved %d)", originalSize, compactedSize, savingBytes)
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
}
// 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)
}
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 nil, fmt.Errorf("failed to fetch issue: %w", err)
}
originalSize := len(issue.Description) + len(issue.Design) + len(issue.Notes) + len(issue.AcceptanceCriteria)
if err := c.CompactTier1(ctx, issueID); err != nil {
return &BatchResult{IssueID: issueID, OriginalSize: originalSize, Err: err}, nil
}
issueAfter, _ := c.store.GetIssue(ctx, issueID)
compactedSize := 0
if issueAfter != nil {
compactedSize = len(issueAfter.Description)
}
return &BatchResult{
IssueID: issueID,
OriginalSize: originalSize,
CompactedSize: compactedSize,
}, nil
}
// 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)
}
// Calculate original size
originalSize := len(issue.Description) + len(issue.Design) + len(issue.Notes) + len(issue.AcceptanceCriteria)
// 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)
}
return nil
}