cmd mempool

cmd/plcbundle/commands/did.go

···
-// repo/cmd/plcbundle/commands/did.go
 package commands
 
 import (

cmd/plcbundle/commands/diff.go

···
-// repo/cmd/plcbundle/commands/diff.go
 package commands
 
 import (

cmd/plcbundle/commands/mempool.go

···
 	"strings"
 	"time"
 
-	flag "github.com/spf13/pflag"
-
+	"github.com/goccy/go-json"
+	"github.com/spf13/cobra"
 	"tangled.org/atscan.net/plcbundle/internal/types"
 )
 
-// MempoolCommand handles the mempool subcommand
-func MempoolCommand(args []string) error {
-	fs := flag.NewFlagSet("mempool", flag.ExitOnError)
-	clear := fs.Bool("clear", false, "clear the mempool")
-	export := fs.Bool("export", false, "export mempool operations as JSONL to stdout")
-	refresh := fs.Bool("refresh", false, "reload mempool from disk")
-	validate := fs.Bool("validate", false, "validate chronological order")
-	verbose := fs.Bool("v", false, "verbose output")
+func NewMempoolCommand() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "mempool [status]",
+		Aliases: []string{"mp"},
+		Short:   "Manage mempool operations",
+		Long: `Manage mempool operations
 
-	if err := fs.Parse(args); err != nil {
-		return err
+The mempool stores operations waiting to be bundled. It maintains
+strict chronological order and automatically validates consistency.`,
+
+		Example: `  # Show mempool status
+  plcbundle mempool
+  plcbundle mempool status
+
+  # Clear all operations
+  plcbundle mempool clear
+
+  # Export operations as JSONL
+  plcbundle mempool dump
+  plcbundle mempool dump > operations.jsonl
+
+  # Using alias
+  plcbundle mp status`,
+
+		RunE: func(cmd *cobra.Command, args []string) error {
+			// Default to status subcommand
+			return mempoolStatus(cmd, args)
+		},
 	}
 
-	mgr, dir, err := getManager("")
+	// Add subcommands
+	cmd.AddCommand(newMempoolStatusCommand())
+	cmd.AddCommand(newMempoolClearCommand())
+	cmd.AddCommand(newMempoolDumpCommand())
+
+	return cmd
+}
+
+// ============================================================================
+// MEMPOOL STATUS - Show current state
+// ============================================================================
+
+func newMempoolStatusCommand() *cobra.Command {
+	var verbose bool
+
+	cmd := &cobra.Command{
+		Use:     "status",
+		Aliases: []string{"s", "info"},
+		Short:   "Show mempool status",
+		Long: `Show mempool status and statistics
+
+Displays current mempool state including operation count, progress toward
+next bundle, validation status, and memory usage.`,
+
+		Example: `  # Show status
+  plcbundle mempool status
+  plcbundle mempool
+
+  # Verbose output with samples
+  plcbundle mempool status -v`,
+
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return mempoolStatus(cmd, args)
+		},
+	}
+
+	cmd.Flags().BoolVarP(&verbose, "verbose", "v", false, "Show sample operations")
+
+	return cmd
+}
+
+func mempoolStatus(cmd *cobra.Command, args []string) error {
+	verbose, _ := cmd.Flags().GetBool("verbose")
+	if cmd.Parent() != nil {
+		// Called as subcommand, check parent's verbose flag
+		if v, err := cmd.Parent().Flags().GetBool("verbose"); err == nil && v {
+			verbose = true
+		}
+	}
+
+	mgr, dir, err := getManagerFromCommand(cmd, "")
 	if err != nil {
 		return err
 	}
 	defer mgr.Close()
 
-	fmt.Printf("Working in: %s\n\n", dir)
+	return showMempoolStatus(mgr, dir, verbose)
+}
 
-	// Handle validate
-	if *validate {
-		fmt.Printf("Validating mempool chronological order...\n")
-		if err := mgr.ValidateMempool(); err != nil {
-			return fmt.Errorf("validation failed: %w", err)
-		}
-		fmt.Printf("✓ Mempool validation passed\n")
-		return nil
-	}
+// ============================================================================
+// MEMPOOL CLEAR - Remove all operations
+// ============================================================================
 
-	// Handle refresh
-	if *refresh {
-		fmt.Printf("Refreshing mempool from disk...\n")
-		if err := mgr.RefreshMempool(); err != nil {
-			return fmt.Errorf("refresh failed: %w", err)
-		}
+func newMempoolClearCommand() *cobra.Command {
+	var force bool
 
-		if err := mgr.ValidateMempool(); err != nil {
-			fmt.Fprintf(os.Stderr, "⚠️  Warning: mempool validation failed after refresh: %v\n", err)
-		} else {
-			fmt.Printf("✓ Mempool refreshed and validated\n\n")
-		}
-	}
+	cmd := &cobra.Command{
+		Use:     "clear",
+		Aliases: []string{"c", "reset"},
+		Short:   "Clear mempool operations",
+		Long: `Clear all operations from mempool
 
-	// Handle clear
-	if *clear {
-		stats := mgr.GetMempoolStats()
-		count := stats["count"].(int)
+Removes all operations from the mempool and saves the empty state.
+This is a destructive operation that cannot be undone.
 
-		if count == 0 {
-			fmt.Println("Mempool is already empty")
-			return nil
-		}
+Use cases:
+  • Reset after testing
+  • Clear corrupted data
+  • Force fresh start`,
 
-		fmt.Printf("⚠️  This will clear %d operations from the mempool.\n", count)
-		fmt.Printf("Are you sure? [y/N]: ")
-		var response string
-		fmt.Scanln(&response)
-		if strings.ToLower(strings.TrimSpace(response)) != "y" {
-			fmt.Println("Cancelled")
-			return nil
-		}
+		Example: `  # Clear with confirmation
+  plcbundle mempool clear
 
-		if err := mgr.ClearMempool(); err != nil {
-			return fmt.Errorf("clear failed: %w", err)
-		}
+  # Force clear without confirmation
+  plcbundle mempool clear --force
+  plcbundle mempool clear -f`,
 
-		fmt.Printf("✓ Mempool cleared (%d operations removed)\n", count)
-		return nil
-	}
+		RunE: func(cmd *cobra.Command, args []string) error {
+			mgr, dir, err := getManagerFromCommand(cmd, "")
+			if err != nil {
+				return err
+			}
+			defer mgr.Close()
 
-	// Handle export
-	if *export {
-		ops, err := mgr.GetMempoolOperations()
-		if err != nil {
-			return fmt.Errorf("failed to get mempool operations: %w", err)
-		}
+			stats := mgr.GetMempoolStats()
+			count := stats["count"].(int)
 
-		if len(ops) == 0 {
-			fmt.Fprintf(os.Stderr, "Mempool is empty\n")
+			if count == 0 {
+				fmt.Println("Mempool is already empty")
+				return nil
+			}
+
+			fmt.Printf("Working in: %s\n\n", dir)
+
+			if !force {
+				fmt.Printf("⚠️  This will clear %d operations from the mempool.\n", count)
+				fmt.Printf("Are you sure? [y/N]: ")
+				var response string
+				fmt.Scanln(&response)
+				if strings.ToLower(strings.TrimSpace(response)) != "y" {
+					fmt.Println("Cancelled")
+					return nil
+				}
+			}
+
+			if err := mgr.ClearMempool(); err != nil {
+				return fmt.Errorf("clear failed: %w", err)
+			}
+
+			fmt.Printf("\n✓ Mempool cleared (%d operations removed)\n", count)
 			return nil
-		}
+		},
+	}
+
+	cmd.Flags().BoolVarP(&force, "force", "f", false, "Skip confirmation prompt")
 
-		for _, op := range ops {
-			if len(op.RawJSON) > 0 {
-				fmt.Println(string(op.RawJSON))
+	return cmd
+}
+
+// ============================================================================
+// MEMPOOL DUMP - Export operations as JSONL
+// ============================================================================
+
+func newMempoolDumpCommand() *cobra.Command {
+	var outputFile string
+
+	cmd := &cobra.Command{
+		Use:     "dump",
+		Aliases: []string{"export", "d"},
+		Short:   "Export mempool as JSONL",
+		Long: `Export mempool operations as JSONL
+
+Outputs all operations in the mempool as newline-delimited JSON.
+Perfect for backup, analysis, or piping to other tools.`,
+
+		Example: `  # Dump to stdout
+  plcbundle mempool dump
+
+  # Save to file
+  plcbundle mempool dump > mempool.jsonl
+  plcbundle mempool dump -o mempool.jsonl
+
+  # Pipe to jq
+  plcbundle mempool dump | jq -r .did
+
+  # Count operations
+  plcbundle mempool dump | wc -l
+
+  # Using alias
+  plcbundle mempool export`,
+
+		RunE: func(cmd *cobra.Command, args []string) error {
+			mgr, _, err := getManagerFromCommand(cmd, "")
+			if err != nil {
+				return err
 			}
-		}
+			defer mgr.Close()
 
-		fmt.Fprintf(os.Stderr, "Exported %d operations from mempool\n", len(ops))
-		return nil
+			ops, err := mgr.GetMempoolOperations()
+			if err != nil {
+				return fmt.Errorf("failed to get mempool operations: %w", err)
+			}
+
+			if len(ops) == 0 {
+				fmt.Fprintf(os.Stderr, "Mempool is empty\n")
+				return nil
+			}
+
+			// Determine output destination
+			var output *os.File
+			if outputFile != "" {
+				output, err = os.Create(outputFile)
+				if err != nil {
+					return fmt.Errorf("failed to create output file: %w", err)
+				}
+				defer output.Close()
+				fmt.Fprintf(os.Stderr, "Exporting to: %s\n", outputFile)
+			} else {
+				output = os.Stdout
+			}
+
+			// Write JSONL
+			for _, op := range ops {
+				if len(op.RawJSON) > 0 {
+					output.Write(op.RawJSON)
+				} else {
+					data, _ := json.Marshal(op)
+					output.Write(data)
+				}
+				output.Write([]byte("\n"))
+			}
+
+			fmt.Fprintf(os.Stderr, "Exported %d operations from mempool\n", len(ops))
+			return nil
+		},
 	}
 
-	// Default: Show mempool stats
-	return showMempoolStats(mgr, dir, *verbose)
+	cmd.Flags().StringVarP(&outputFile, "output", "o", "", "Output file (default: stdout)")
+
+	return cmd
 }
 
-func showMempoolStats(mgr BundleManager, dir string, verbose bool) error {
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+
+func showMempoolStatus(mgr BundleManager, dir string, verbose bool) error {
 	stats := mgr.GetMempoolStats()
 	count := stats["count"].(int)
 	canCreate := stats["can_create_bundle"].(bool)
···
 	minTimestamp := stats["min_timestamp"].(time.Time)
 	validated := stats["validated"].(bool)
 
-	fmt.Printf("Mempool Status:\n")
-	fmt.Printf("  Target bundle: %06d\n", targetBundle)
-	fmt.Printf("  Operations: %d\n", count)
-	fmt.Printf("  Can create bundle: %v (need %d)\n", canCreate, types.BUNDLE_SIZE)
-	fmt.Printf("  Min timestamp: %s\n", minTimestamp.Format("2006-01-02 15:04:05"))
+	fmt.Printf("Mempool Status\n")
+	fmt.Printf("══════════════\n\n")
+	fmt.Printf("  Directory:      %s\n", dir)
+	fmt.Printf("  Target bundle:  %06d\n", targetBundle)
+	fmt.Printf("  Operations:     %d / %d\n", count, types.BUNDLE_SIZE)
+	fmt.Printf("  Min timestamp:  %s\n\n", minTimestamp.Format("2006-01-02 15:04:05"))
 
+	// Validation status
 	validationIcon := "✓"
 	if !validated {
 		validationIcon = "⚠️"
 	}
-	fmt.Printf("  Validated: %s %v\n", validationIcon, validated)
+	fmt.Printf("  Validated:      %s %v\n", validationIcon, validated)
 
 	if count > 0 {
+		// Size information
 		if sizeBytes, ok := stats["size_bytes"].(int); ok {
-			fmt.Printf("  Size: %.2f KB\n", float64(sizeBytes)/1024)
+			fmt.Printf("  Size:           %.2f KB\n", float64(sizeBytes)/1024)
 		}
 
+		// Time range
 		if firstTime, ok := stats["first_time"].(time.Time); ok {
-			fmt.Printf("  First operation: %s\n", firstTime.Format("2006-01-02 15:04:05"))
+			fmt.Printf("  First op:       %s\n", firstTime.Format("2006-01-02 15:04:05"))
 		}
-
 		if lastTime, ok := stats["last_time"].(time.Time); ok {
-			fmt.Printf("  Last operation: %s\n", lastTime.Format("2006-01-02 15:04:05"))
+			fmt.Printf("  Last op:        %s\n", lastTime.Format("2006-01-02 15:04:05"))
 		}
 
+		fmt.Printf("\n")
+
+		// Progress bar
 		progress := float64(count) / float64(types.BUNDLE_SIZE) * 100
-		fmt.Printf("  Progress: %.1f%% (%d/%d)\n", progress, count, types.BUNDLE_SIZE)
+		fmt.Printf("  Progress:       %.1f%% (%d/%d)\n", progress, count, types.BUNDLE_SIZE)
 
-		// Progress bar
 		barWidth := 40
 		filled := int(float64(barWidth) * float64(count) / float64(types.BUNDLE_SIZE))
 		if filled > barWidth {
 			filled = barWidth
 		}
 		bar := strings.Repeat("█", filled) + strings.Repeat("░", barWidth-filled)
-		fmt.Printf("  [%s]\n", bar)
+		fmt.Printf("  [%s]\n\n", bar)
+
+		// Bundle creation status
+		if canCreate {
+			fmt.Printf("  ✓ Ready to create bundle\n")
+		} else {
+			remaining := types.BUNDLE_SIZE - count
+			fmt.Printf("  Need %s more operations\n", formatNumber(remaining))
+		}
 	} else {
-		fmt.Printf("  (empty)\n")
+		fmt.Printf("\n  (empty)\n")
 	}
+
+	fmt.Printf("\n")
 
 	// Verbose: Show sample operations
 	if verbose && count > 0 {
-		fmt.Println()
-		fmt.Printf("Sample operations (showing up to 10):\n")
+		fmt.Printf("Sample Operations (first 10)\n")
+		fmt.Printf("────────────────────────────\n\n")
 
 		ops, err := mgr.GetMempoolOperations()
 		if err != nil {
···
 			fmt.Printf("  %d. DID: %s\n", i+1, op.DID)
 			fmt.Printf("     CID: %s\n", op.CID)
 			fmt.Printf("     Created: %s\n", op.CreatedAt.Format("2006-01-02 15:04:05.000"))
+			fmt.Printf("\n")
 		}
 
 		if len(ops) > showCount {
-			fmt.Printf("  ... and %d more\n", len(ops)-showCount)
+			fmt.Printf("  ... and %d more\n\n", len(ops)-showCount)
 		}
 	}
 
-	fmt.Println()
-
-	// Show mempool file
+	// Show mempool file location
 	mempoolFilename := fmt.Sprintf("plc_mempool_%06d.jsonl", targetBundle)
 	fmt.Printf("File: %s\n", filepath.Join(dir, mempoolFilename))
 

cmd/plcbundle/commands/server.go

···
-// cmd/plcbundle/commands/server.go
 package commands
 
 import (

cmd/plcbundle/commands/status.go

···
-// repo/cmd/plcbundle/commands/status.go
 package commands
 
 import (

cmd/plcbundle/commands/stream.go

···
-// repo/cmd/plcbundle/commands/stream.go
 package commands
 
 import (

cmd/plcbundle/commands/sync.go

···
-// cmd/plcbundle/commands/sync.go
 package commands
 
 import (

cmd/plcbundle/main.go

···
 
 	// Namespaced commands
 	cmd.AddCommand(commands.NewDIDCommand())
-	/*cmd.AddCommand(commands.NewIndexCommand())
+	//cmd.AddCommand(commands.NewIndexCommand())
 	cmd.AddCommand(commands.NewMempoolCommand())
-	cmd.AddCommand(commands.NewDetectorCommand())
+	/*cmd.AddCommand(commands.NewDetectorCommand())
 
 	// Monitoring & maintenance
 	cmd.AddCommand(commands.NewWatchCommand())