3363f91844
Adds ability to burn multiple molecules in a single command: bd mol burn bd-a1 bd-b2 bd-c3 Changes: - Accept multiple molecule IDs as arguments - Add BatchBurnResult struct for aggregated results - Implement burnMultipleMolecules for batch efficiency - Wisps deleted in single batch call - Maintains backward compatibility for single ID Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
425 lines
12 KiB
Go
425 lines
12 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
|
|
"github.com/spf13/cobra"
|
|
"github.com/steveyegge/beads/internal/storage/sqlite"
|
|
"github.com/steveyegge/beads/internal/ui"
|
|
"github.com/steveyegge/beads/internal/utils"
|
|
)
|
|
|
|
var molBurnCmd = &cobra.Command{
|
|
Use: "burn <molecule-id> [molecule-id...]",
|
|
Short: "Delete a molecule without creating a digest",
|
|
Long: `Burn a molecule, deleting it without creating a digest.
|
|
|
|
Unlike squash (which creates a permanent digest before deletion), burn
|
|
completely removes the molecule with no trace. Use this for:
|
|
- Abandoned patrol cycles
|
|
- Crashed or failed workflows
|
|
- Test/debug molecules you don't want to preserve
|
|
|
|
The burn operation differs based on molecule phase:
|
|
- Wisp (ephemeral): Direct delete, no tombstones
|
|
- Mol (persistent): Cascade delete with tombstones (syncs to remotes)
|
|
|
|
CAUTION: This is a destructive operation. The molecule's data will be
|
|
permanently lost. If you want to preserve a summary, use 'bd mol squash'.
|
|
|
|
Example:
|
|
bd mol burn bd-abc123 # Delete molecule with no trace
|
|
bd mol burn bd-abc123 --dry-run # Preview what would be deleted
|
|
bd mol burn bd-abc123 --force # Skip confirmation
|
|
bd mol burn bd-a1 bd-b2 bd-c3 # Batch delete multiple wisps`,
|
|
Args: cobra.MinimumNArgs(1),
|
|
Run: runMolBurn,
|
|
}
|
|
|
|
// BurnResult holds the result of a burn operation
|
|
type BurnResult struct {
|
|
MoleculeID string `json:"molecule_id"`
|
|
DeletedIDs []string `json:"deleted_ids"`
|
|
DeletedCount int `json:"deleted_count"`
|
|
}
|
|
|
|
// BatchBurnResult holds aggregated results when burning multiple molecules
|
|
type BatchBurnResult struct {
|
|
Results []BurnResult `json:"results"`
|
|
TotalDeleted int `json:"total_deleted"`
|
|
FailedCount int `json:"failed_count"`
|
|
}
|
|
|
|
func runMolBurn(cmd *cobra.Command, args []string) {
|
|
CheckReadonly("mol burn")
|
|
|
|
ctx := rootCtx
|
|
|
|
// mol burn requires direct store access (daemon auto-bypassed for wisp ops)
|
|
if store == nil {
|
|
fmt.Fprintf(os.Stderr, "Error: no database connection\n")
|
|
fmt.Fprintf(os.Stderr, "Hint: run 'bd init' or 'bd import' to initialize the database\n")
|
|
os.Exit(1)
|
|
}
|
|
|
|
dryRun, _ := cmd.Flags().GetBool("dry-run")
|
|
force, _ := cmd.Flags().GetBool("force")
|
|
|
|
// Single ID: use original logic for backward compatibility
|
|
if len(args) == 1 {
|
|
burnSingleMolecule(ctx, args[0], dryRun, force)
|
|
return
|
|
}
|
|
|
|
// Multiple IDs: batch mode for efficiency
|
|
burnMultipleMolecules(ctx, args, dryRun, force)
|
|
}
|
|
|
|
// burnSingleMolecule handles the single molecule case (original behavior)
|
|
func burnSingleMolecule(ctx context.Context, moleculeID string, dryRun, force bool) {
|
|
// Resolve molecule ID in main store
|
|
resolvedID, err := utils.ResolvePartialID(ctx, store, moleculeID)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error resolving molecule ID %s: %v\n", moleculeID, err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
// Load the molecule
|
|
rootIssue, err := store.GetIssue(ctx, resolvedID)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error loading molecule: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
// Branch based on molecule phase
|
|
if rootIssue.Ephemeral {
|
|
// Wisp: direct delete without tombstones
|
|
burnWispMolecule(ctx, resolvedID, dryRun, force)
|
|
} else {
|
|
// Mol: cascade delete with tombstones
|
|
burnPersistentMolecule(ctx, resolvedID, dryRun, force)
|
|
}
|
|
}
|
|
|
|
// burnMultipleMolecules handles batch deletion of multiple molecules efficiently
|
|
func burnMultipleMolecules(ctx context.Context, moleculeIDs []string, dryRun, force bool) {
|
|
var wispIDs []string
|
|
var persistentIDs []string
|
|
var failedResolve []string
|
|
|
|
// First pass: resolve and categorize all IDs
|
|
for _, moleculeID := range moleculeIDs {
|
|
resolvedID, err := utils.ResolvePartialID(ctx, store, moleculeID)
|
|
if err != nil {
|
|
if !jsonOutput {
|
|
fmt.Fprintf(os.Stderr, "Warning: failed to resolve %s: %v\n", moleculeID, err)
|
|
}
|
|
failedResolve = append(failedResolve, moleculeID)
|
|
continue
|
|
}
|
|
|
|
issue, err := store.GetIssue(ctx, resolvedID)
|
|
if err != nil {
|
|
if !jsonOutput {
|
|
fmt.Fprintf(os.Stderr, "Warning: failed to load %s: %v\n", resolvedID, err)
|
|
}
|
|
failedResolve = append(failedResolve, moleculeID)
|
|
continue
|
|
}
|
|
|
|
if issue.Ephemeral {
|
|
wispIDs = append(wispIDs, resolvedID)
|
|
} else {
|
|
persistentIDs = append(persistentIDs, resolvedID)
|
|
}
|
|
}
|
|
|
|
if len(wispIDs) == 0 && len(persistentIDs) == 0 {
|
|
if jsonOutput {
|
|
outputJSON(BatchBurnResult{FailedCount: len(failedResolve)})
|
|
} else {
|
|
fmt.Println("No valid molecules to burn")
|
|
}
|
|
return
|
|
}
|
|
|
|
if dryRun {
|
|
if !jsonOutput {
|
|
fmt.Printf("\nDry run: would burn %d wisp(s) and %d persistent molecule(s)\n", len(wispIDs), len(persistentIDs))
|
|
if len(wispIDs) > 0 {
|
|
fmt.Printf("\nWisps to delete:\n")
|
|
for _, id := range wispIDs {
|
|
fmt.Printf(" - %s\n", id)
|
|
}
|
|
}
|
|
if len(persistentIDs) > 0 {
|
|
fmt.Printf("\nPersistent molecules to delete (will create tombstones):\n")
|
|
for _, id := range persistentIDs {
|
|
fmt.Printf(" - %s\n", id)
|
|
}
|
|
}
|
|
if len(failedResolve) > 0 {
|
|
fmt.Printf("\nFailed to resolve (%d):\n", len(failedResolve))
|
|
for _, id := range failedResolve {
|
|
fmt.Printf(" - %s\n", id)
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// Confirm unless --force
|
|
if !force && !jsonOutput {
|
|
fmt.Printf("About to burn %d wisp(s) and %d persistent molecule(s)\n", len(wispIDs), len(persistentIDs))
|
|
fmt.Printf("This will permanently delete all molecule data with no digest.\n")
|
|
fmt.Printf("\nContinue? [y/N] ")
|
|
|
|
var response string
|
|
_, _ = fmt.Scanln(&response)
|
|
if response != "y" && response != "Y" {
|
|
fmt.Println("Canceled.")
|
|
return
|
|
}
|
|
}
|
|
|
|
batchResult := BatchBurnResult{
|
|
Results: make([]BurnResult, 0),
|
|
FailedCount: len(failedResolve),
|
|
}
|
|
|
|
// Batch delete all wisps in one call
|
|
if len(wispIDs) > 0 {
|
|
result, err := burnWisps(ctx, store, wispIDs)
|
|
if err != nil {
|
|
if !jsonOutput {
|
|
fmt.Fprintf(os.Stderr, "Error burning wisps: %v\n", err)
|
|
}
|
|
} else {
|
|
batchResult.TotalDeleted += result.DeletedCount
|
|
batchResult.Results = append(batchResult.Results, *result)
|
|
}
|
|
}
|
|
|
|
// Handle persistent molecules individually (they need subgraph loading)
|
|
for _, id := range persistentIDs {
|
|
subgraph, err := loadTemplateSubgraph(ctx, store, id)
|
|
if err != nil {
|
|
if !jsonOutput {
|
|
fmt.Fprintf(os.Stderr, "Warning: failed to load subgraph for %s: %v\n", id, err)
|
|
}
|
|
batchResult.FailedCount++
|
|
continue
|
|
}
|
|
|
|
var issueIDs []string
|
|
for _, issue := range subgraph.Issues {
|
|
issueIDs = append(issueIDs, issue.ID)
|
|
}
|
|
|
|
// Use deleteBatch for persistent molecules
|
|
deleteBatch(nil, issueIDs, true, false, false, false, false, "mol burn")
|
|
batchResult.TotalDeleted += len(issueIDs)
|
|
batchResult.Results = append(batchResult.Results, BurnResult{
|
|
MoleculeID: id,
|
|
DeletedIDs: issueIDs,
|
|
DeletedCount: len(issueIDs),
|
|
})
|
|
}
|
|
|
|
// Schedule auto-flush
|
|
markDirtyAndScheduleFlush()
|
|
|
|
if jsonOutput {
|
|
outputJSON(batchResult)
|
|
return
|
|
}
|
|
|
|
fmt.Printf("%s Burned %d molecule(s): %d issues deleted\n", ui.RenderPass("✓"), len(wispIDs)+len(persistentIDs), batchResult.TotalDeleted)
|
|
if batchResult.FailedCount > 0 {
|
|
fmt.Printf(" %d failed\n", batchResult.FailedCount)
|
|
}
|
|
}
|
|
|
|
// burnWispMolecule handles wisp deletion (no tombstones, ephemeral-only)
|
|
func burnWispMolecule(ctx context.Context, resolvedID string, dryRun, force bool) {
|
|
// Load the molecule subgraph
|
|
subgraph, err := loadTemplateSubgraph(ctx, store, resolvedID)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error loading wisp molecule: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
// Collect wisp issue IDs to delete (only delete wisps, not regular children)
|
|
var wispIDs []string
|
|
for _, issue := range subgraph.Issues {
|
|
if issue.Ephemeral {
|
|
wispIDs = append(wispIDs, issue.ID)
|
|
}
|
|
}
|
|
|
|
if len(wispIDs) == 0 {
|
|
if jsonOutput {
|
|
outputJSON(BurnResult{
|
|
MoleculeID: resolvedID,
|
|
DeletedCount: 0,
|
|
})
|
|
} else {
|
|
fmt.Printf("No wisp issues found for molecule %s\n", resolvedID)
|
|
}
|
|
return
|
|
}
|
|
|
|
if dryRun {
|
|
fmt.Printf("\nDry run: would burn wisp %s\n\n", resolvedID)
|
|
fmt.Printf("Root: %s\n", subgraph.Root.Title)
|
|
fmt.Printf("\nWisp issues to delete (%d total):\n", len(wispIDs))
|
|
for _, issue := range subgraph.Issues {
|
|
if !issue.Ephemeral {
|
|
continue
|
|
}
|
|
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("\nNo digest will be created (use 'bd mol squash' to create one).\n")
|
|
return
|
|
}
|
|
|
|
// Confirm unless --force
|
|
if !force && !jsonOutput {
|
|
fmt.Printf("About to burn wisp %s (%d issues)\n", resolvedID, len(wispIDs))
|
|
fmt.Printf("This will permanently delete all wisp data with no digest.\n")
|
|
fmt.Printf("Use 'bd mol squash' instead if you want to preserve a summary.\n")
|
|
fmt.Printf("\nContinue? [y/N] ")
|
|
|
|
var response string
|
|
_, _ = fmt.Scanln(&response)
|
|
if response != "y" && response != "Y" {
|
|
fmt.Println("Canceled.")
|
|
return
|
|
}
|
|
}
|
|
|
|
// Perform the burn
|
|
result, err := burnWisps(ctx, store, wispIDs)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error burning wisp: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
result.MoleculeID = resolvedID
|
|
|
|
// Schedule auto-flush
|
|
markDirtyAndScheduleFlush()
|
|
|
|
if jsonOutput {
|
|
outputJSON(result)
|
|
return
|
|
}
|
|
|
|
fmt.Printf("%s Burned wisp: %d issues deleted\n", ui.RenderPass("✓"), result.DeletedCount)
|
|
fmt.Printf(" Ephemeral: %s\n", resolvedID)
|
|
fmt.Printf(" No digest created.\n")
|
|
}
|
|
|
|
// burnPersistentMolecule handles mol deletion (with tombstones, cascade delete)
|
|
func burnPersistentMolecule(ctx context.Context, resolvedID string, dryRun, force bool) {
|
|
// Load the molecule subgraph to show what will be deleted
|
|
subgraph, err := loadTemplateSubgraph(ctx, store, resolvedID)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error loading molecule: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
// Collect all issue IDs in the molecule
|
|
var issueIDs []string
|
|
for _, issue := range subgraph.Issues {
|
|
issueIDs = append(issueIDs, issue.ID)
|
|
}
|
|
|
|
if len(issueIDs) == 0 {
|
|
if jsonOutput {
|
|
outputJSON(BurnResult{
|
|
MoleculeID: resolvedID,
|
|
DeletedCount: 0,
|
|
})
|
|
} else {
|
|
fmt.Printf("No issues found for molecule %s\n", resolvedID)
|
|
}
|
|
return
|
|
}
|
|
|
|
if dryRun {
|
|
fmt.Printf("\nDry run: would burn mol %s\n\n", resolvedID)
|
|
fmt.Printf("Root: %s\n", subgraph.Root.Title)
|
|
fmt.Printf("\nIssues to delete (%d total):\n", len(issueIDs))
|
|
for _, issue := range subgraph.Issues {
|
|
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("\nNote: Persistent mol - will create tombstones (syncs to remotes).\n")
|
|
fmt.Printf("No digest will be created (use 'bd mol squash' to create one).\n")
|
|
return
|
|
}
|
|
|
|
// Confirm unless --force
|
|
if !force && !jsonOutput {
|
|
fmt.Printf("About to burn mol %s (%d issues)\n", resolvedID, len(issueIDs))
|
|
fmt.Printf("This will permanently delete all molecule data with no digest.\n")
|
|
fmt.Printf("Note: Persistent mol - tombstones will sync to remotes.\n")
|
|
fmt.Printf("Use 'bd mol squash' instead if you want to preserve a summary.\n")
|
|
fmt.Printf("\nContinue? [y/N] ")
|
|
|
|
var response string
|
|
_, _ = fmt.Scanln(&response)
|
|
if response != "y" && response != "Y" {
|
|
fmt.Println("Canceled.")
|
|
return
|
|
}
|
|
}
|
|
|
|
// Use deleteBatch with cascade=false (we already have all IDs from subgraph)
|
|
// force=true, hardDelete=false (keep tombstones for sync)
|
|
deleteBatch(nil, issueIDs, true, false, false, jsonOutput, false, "mol burn")
|
|
}
|
|
|
|
// burnWisps deletes all wisp issues without creating a digest
|
|
func burnWisps(ctx context.Context, s interface{}, ids []string) (*BurnResult, error) {
|
|
// Type assert to SQLite storage for delete access
|
|
sqliteStore, ok := s.(*sqlite.SQLiteStorage)
|
|
if !ok {
|
|
return nil, fmt.Errorf("burn requires SQLite storage backend")
|
|
}
|
|
|
|
result := &BurnResult{
|
|
DeletedIDs: make([]string, 0, len(ids)),
|
|
}
|
|
|
|
for _, id := range ids {
|
|
if err := sqliteStore.DeleteIssue(ctx, id); err != nil {
|
|
// Log but continue - try to delete as many as possible
|
|
fmt.Fprintf(os.Stderr, "Warning: failed to delete %s: %v\n", id, err)
|
|
continue
|
|
}
|
|
result.DeletedIDs = append(result.DeletedIDs, id)
|
|
result.DeletedCount++
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
func init() {
|
|
molBurnCmd.Flags().Bool("dry-run", false, "Preview what would be deleted")
|
|
molBurnCmd.Flags().Bool("force", false, "Skip confirmation prompt")
|
|
|
|
molCmd.AddCommand(molBurnCmd)
|
|
}
|