johno/beads
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: simplify wisp architecture - single DB with Wisp flag (bd-bkul)

Browse Source 
- Remove cross-store squash logic from mol_squash.go
  - Delete runWispSquash() and squashWispToPermanent() functions
  - Simplify runMolSquash() to work with main store only

- Update mol_burn.go to work with main database
  - Remove .beads-wisp/ directory references
  - Look for Wisp=true issues in main store instead

- Update mol_bond.go to use Wisp flag instead of separate store
  - --wisp now creates issues with Wisp=true in main store
  - --pour creates issues with Wisp=false (persistent)
  - Update bondProtoMol signature to accept both flags

- Deprecate wisp storage functions in beads.go
  - WispDirName, FindWispDir, FindWispDatabasePath
  - NewWispStorage, EnsureWispGitignore, IsWispDatabase
  - All marked deprecated with reference to bd-bkul

- Remove obsolete cross-store squash tests
  - TestSquashWispToPermanent
  - TestSquashWispToPermanentWithSummary
  - TestSquashWispToPermanentKeepChildren

All tests pass. Build succeeds.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
Steve Yegge
2025-12-24 20:42:54 -08:00
parent c0271aedbf
commit f2e6df95c0
6 changed files with 121 additions and 583 deletions
Download Patch File Download Diff File Expand all files Collapse all files

198
cmd/bd/mol_squash.go
View File

@@ -81,54 +81,13 @@ func runMolSquash(cmd *cobra.Command, args []string) {
keepChildren, _ := cmd.Flags().GetBool("keep-children")
summary, _ := cmd.Flags().GetString("summary")
// Try to resolve molecule ID in main store first
// Resolve molecule ID in main store
moleculeID, err := utils.ResolvePartialID(ctx, store, args[0])
// If not found in main store, check wisp storage
if err != nil {
// Try wisp storage
wispStore, wispErr := beads.NewWispStorage(ctx)
if wispErr != nil {
// No wisp storage available, report original error
fmt.Fprintf(os.Stderr, "Error resolving molecule ID %s: %v\n", args[0], err)
os.Exit(1)
}
defer func() { _ = wispStore.Close() }()
wispMolID, wispResolveErr := utils.ResolvePartialID(ctx, wispStore, args[0])
if wispResolveErr != nil {
// Not found in either store
fmt.Fprintf(os.Stderr, "Error resolving molecule ID %s: %v\n", args[0], err)
os.Exit(1)
}
// Found in wisp storage - do cross-store squash
runWispSquash(ctx, cmd, wispStore, store, wispMolID, dryRun, keepChildren, summary)
return
}
// Found in main store - check if it's actually a wisp by looking at root
issue, err := store.GetIssue(ctx, moleculeID)
if err != nil {
fmt.Fprintf(os.Stderr, "Error loading molecule: %v\n", err)
fmt.Fprintf(os.Stderr, "Error resolving molecule ID %s: %v\n", args[0], err)
os.Exit(1)
}
// If the root itself is a wisp, check if it should be in wisp storage
// This handles the case where someone created a wisp in main store by mistake
if issue.Wisp {
// Check if there's a corresponding wisp in wisp storage
wispStore, wispErr := beads.NewWispStorage(ctx)
if wispErr == nil {
defer func() { _ = wispStore.Close() }()
if wispIssue, _ := wispStore.GetIssue(ctx, moleculeID); wispIssue != nil {
// Found in wisp storage - do cross-store squash
runWispSquash(ctx, cmd, wispStore, store, moleculeID, dryRun, keepChildren, summary)
return
}
}
}
// Load the molecule subgraph from main store
subgraph, err := loadTemplateSubgraph(ctx, store, moleculeID)
if err != nil {
@@ -207,80 +166,6 @@ func runMolSquash(cmd *cobra.Command, args []string) {
}
}
// runWispSquash handles squashing a wisp from wisp storage into permanent storage.
// This is the cross-store squash operation: load from wisp, create digest in permanent, delete wisp.
func runWispSquash(ctx context.Context, _ *cobra.Command, wispStore, permanentStore storage.Storage, moleculeID string, dryRun, keepChildren bool, summary string) {
// Load the molecule subgraph from wisp storage
subgraph, err := loadTemplateSubgraph(ctx, wispStore, moleculeID)
if err != nil {
fmt.Fprintf(os.Stderr, "Error loading wisp molecule: %v\n", err)
os.Exit(1)
}
// Collect all issues in the wisp (including root)
allIssues := subgraph.Issues
if dryRun {
fmt.Printf("\nDry run: would squash wisp %s → permanent digest\n\n", moleculeID)
fmt.Printf("Root: %s\n", subgraph.Root.Title)
fmt.Printf("Storage: .beads-wisp/ → .beads/\n")
fmt.Printf("\nIssues to squash (%d total):\n", len(allIssues))
for _, issue := range allIssues {
status := string(issue.Status)
if issue.ID == subgraph.Root.ID {
fmt.Printf(" - [%s] %s (%s) [ROOT]\n", status, issue.Title, issue.ID)
} else {
fmt.Printf(" - [%s] %s (%s)\n", status, issue.Title, issue.ID)
}
}
fmt.Printf("\nDigest preview:\n")
// For wisp squash, we generate a digest from all issues
var children []*types.Issue
for _, issue := range allIssues {
if issue.ID != subgraph.Root.ID {
children = append(children, issue)
}
}
digest := generateDigest(subgraph.Root, children)
if len(digest) > 500 {
fmt.Printf("%s...\n", digest[:500])
} else {
fmt.Printf("%s\n", digest)
}
if keepChildren {
fmt.Printf("\n--keep-children: wisp would NOT be deleted from .beads-wisp/\n")
} else {
fmt.Printf("\nWisp will be deleted from .beads-wisp/ after digest creation.\n")
}
return
}
// Perform the cross-store squash
result, err := squashWispToPermanent(ctx, wispStore, permanentStore, subgraph, keepChildren, summary, actor)
if err != nil {
fmt.Fprintf(os.Stderr, "Error squashing wisp: %v\n", err)
os.Exit(1)
}
// Schedule auto-flush for permanent store
markDirtyAndScheduleFlush()
if jsonOutput {
outputJSON(result)
return
}
fmt.Printf("%s Squashed wisp → permanent digest\n", ui.RenderPass("✓"))
fmt.Printf(" Wisp: %s (.beads-wisp/)\n", moleculeID)
fmt.Printf(" Digest: %s (.beads/)\n", result.DigestID)
fmt.Printf(" Squashed: %d issues\n", result.SquashedCount)
if result.DeletedCount > 0 {
fmt.Printf(" Deleted: %d issues from wisp storage\n", result.DeletedCount)
} else if result.KeptChildren {
fmt.Printf(" Wisp preserved (--keep-children)\n")
}
}
// generateDigest creates a summary from the molecule execution
// Tier 2: Simple concatenation of titles and descriptions
// Tier 3 (future): AI-powered summarization using Haiku
@@ -432,85 +317,6 @@ func deleteWispChildren(ctx context.Context, s storage.Storage, ids []string) (i
return deleted, lastErr
}
// squashWispToPermanent performs a cross-store squash: wisp → permanent digest.
// This is the key operation for wisp lifecycle management:
// 1. Creates a digest issue in permanent storage summarizing the wisp's work
// 2. Deletes the entire wisp molecule from wisp storage
//
// The digest captures the outcome of the ephemeral work without preserving
// the full execution trace (which would accumulate unbounded over time).
func squashWispToPermanent(ctx context.Context, wispStore, permanentStore storage.Storage, subgraph *MoleculeSubgraph, keepChildren bool, summary string, actorName string) (*SquashResult, error) {
if wispStore == nil || permanentStore == nil {
return nil, fmt.Errorf("both wisp and permanent stores are required")
}
root := subgraph.Root
// Collect all issue IDs (including root)
var allIDs []string
var children []*types.Issue
for _, issue := range subgraph.Issues {
allIDs = append(allIDs, issue.ID)
if issue.ID != root.ID {
children = append(children, issue)
}
}
// Use agent-provided summary if available, otherwise generate basic digest
var digestContent string
if summary != "" {
digestContent = summary
} else {
digestContent = generateDigest(root, children)
}
// Create digest issue in permanent storage (not a wisp)
now := time.Now()
digestIssue := &types.Issue{
Title: fmt.Sprintf("Digest: %s @ %s", root.Title, now.Format("2006-01-02 15:04")),
Description: digestContent,
Status: types.StatusClosed,
CloseReason: fmt.Sprintf("Squashed from wisp %s (%d issues)", root.ID, len(subgraph.Issues)),
Priority: root.Priority,
IssueType: types.TypeTask,
Wisp: false, // Digest is permanent
ClosedAt: &now,
}
result := &SquashResult{
MoleculeID: root.ID,
SquashedIDs: allIDs,
SquashedCount: len(subgraph.Issues),
KeptChildren: keepChildren,
WispSquash: true,
}
// Create digest in permanent storage
err := permanentStore.RunInTransaction(ctx, func(tx storage.Transaction) error {
if err := tx.CreateIssue(ctx, digestIssue, actorName); err != nil {
return fmt.Errorf("failed to create digest issue: %w", err)
}
result.DigestID = digestIssue.ID
return nil
})
if err != nil {
return nil, err
}
// Delete wisp issues from wisp storage (unless --keep-children)
if !keepChildren {
deleted, err := deleteWispChildren(ctx, wispStore, allIDs)
if err != nil {
// Log but don't fail - digest was created successfully
fmt.Fprintf(os.Stderr, "Warning: failed to delete some wisp issues: %v\n", err)
}
result.DeletedCount = deleted
}
return result, nil
}
func init() {
molSquashCmd.Flags().Bool("dry-run", false, "Preview what would be squashed")
molSquashCmd.Flags().Bool("keep-children", false, "Don't delete wisp children after squash")