feat(pub): update publication commands with output options and plaintext support

cmd/publication_commands.go

···
 			isDraft, _ := cmd.Flags().GetBool("draft")
 			preview, _ := cmd.Flags().GetBool("preview")
 			validate, _ := cmd.Flags().GetBool("validate")
+			output, _ := cmd.Flags().GetString("output")
+			plaintext, _ := cmd.Flags().GetBool("plaintext")
+			txt, _ := cmd.Flags().GetBool("txt")
+
+			if txt {
+				plaintext = true
+			}
 
 			defer c.handler.Close()
 
 			if preview {
-				return c.handler.PostPreview(cmd.Context(), noteID, isDraft)
+				return c.handler.PostPreview(cmd.Context(), noteID, isDraft, output, plaintext)
 			}
 
 			if validate {
-				return c.handler.PostValidate(cmd.Context(), noteID, isDraft)
+				return c.handler.PostValidate(cmd.Context(), noteID, isDraft, output, plaintext)
 			}
 
 			return c.handler.Post(cmd.Context(), noteID, isDraft)
···
 	postCmd.Flags().Bool("draft", false, "Create as draft instead of publishing")
 	postCmd.Flags().Bool("preview", false, "Show what would be posted without actually posting")
 	postCmd.Flags().Bool("validate", false, "Validate markdown conversion without posting")
+	postCmd.Flags().StringP("output", "o", "", "Write document to file (defaults to JSON format)")
+	postCmd.Flags().Bool("plaintext", false, "Use plaintext format for output file")
+	postCmd.Flags().Bool("txt", false, "Alias for --plaintext")
 	root.AddCommand(postCmd)
 
 	patchCmd := &cobra.Command{
···
 
 			preview, _ := cmd.Flags().GetBool("preview")
 			validate, _ := cmd.Flags().GetBool("validate")
+			output, _ := cmd.Flags().GetString("output")
+			plaintext, _ := cmd.Flags().GetBool("plaintext")
+			txt, _ := cmd.Flags().GetBool("txt")
+
+			if txt {
+				plaintext = true
+			}
 
 			defer c.handler.Close()
 
 			if preview {
-				return c.handler.PatchPreview(cmd.Context(), noteID)
+				return c.handler.PatchPreview(cmd.Context(), noteID, output, plaintext)
 			}
 
 			if validate {
-				return c.handler.PatchValidate(cmd.Context(), noteID)
+				return c.handler.PatchValidate(cmd.Context(), noteID, output, plaintext)
 			}
 
 			return c.handler.Patch(cmd.Context(), noteID)
···
 	}
 	patchCmd.Flags().Bool("preview", false, "Show what would be updated without actually patching")
 	patchCmd.Flags().Bool("validate", false, "Validate markdown conversion without patching")
+	patchCmd.Flags().StringP("output", "o", "", "Write document to file (defaults to JSON format)")
+	patchCmd.Flags().Bool("plaintext", false, "Use plaintext format for output file")
+	patchCmd.Flags().Bool("txt", false, "Alias for --plaintext")
 	root.AddCommand(patchCmd)
 
 	pushCmd := &cobra.Command{

internal/handlers/publication.go

···
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
+	"os"
 	"path/filepath"
 	"time"
 
···
 	return note, doc, nil
 }
 
+// writeDocumentOutput writes document to a file in JSON or plaintext format
+func writeDocumentOutput(doc *public.Document, note *models.Note, outputPath string, plaintext bool) error {
+	var content []byte
+	var err error
+
+	if plaintext {
+		status := "published"
+		if note != nil && note.IsDraft {
+			status = "draft"
+		}
+
+		output := "Document Preview\n"
+		output += "================\n\n"
+		output += fmt.Sprintf("Title: %s\n", doc.Title)
+		output += fmt.Sprintf("Status: %s\n", status)
+		if note != nil {
+			output += fmt.Sprintf("Note ID: %d\n", note.ID)
+			if note.LeafletRKey != nil {
+				output += fmt.Sprintf("RKey: %s\n", *note.LeafletRKey)
+			}
+		}
+		output += fmt.Sprintf("Pages: %d\n", len(doc.Pages))
+		if len(doc.Pages) > 0 {
+			output += fmt.Sprintf("Blocks: %d\n", len(doc.Pages[0].Blocks))
+		}
+		if doc.PublishedAt != "" {
+			output += fmt.Sprintf("PublishedAt: %s\n", doc.PublishedAt)
+		}
+		if doc.Author != "" {
+			output += fmt.Sprintf("Author: %s\n", doc.Author)
+		}
+
+		content = []byte(output)
+	} else {
+		content, err = json.MarshalIndent(doc, "", "  ")
+		if err != nil {
+			return fmt.Errorf("failed to marshal document to JSON: %w", err)
+		}
+	}
+
+	if err := os.WriteFile(outputPath, content, 0644); err != nil {
+		return fmt.Errorf("failed to write output to %s: %w", outputPath, err)
+	}
+
+	return nil
+}
+
 // PostPreview shows what would be posted without actually posting
-func (h *PublicationHandler) PostPreview(ctx context.Context, noteID int64, isDraft bool) error {
+func (h *PublicationHandler) PostPreview(ctx context.Context, noteID int64, isDraft bool, outputPath string, plaintext bool) error {
 	if !h.atproto.IsAuthenticated() {
 		return fmt.Errorf("not authenticated - run 'noteleaf pub auth' first")
 	}
···
 		ui.Infoln("  PublishedAt: %s", doc.PublishedAt)
 	}
 	ui.Infoln("  Note ID: %d", note.ID)
+
+	if outputPath != "" {
+		if err := writeDocumentOutput(doc, note, outputPath, plaintext); err != nil {
+			return err
+		}
+		format := "JSON"
+		if plaintext {
+			format = "plaintext"
+		}
+		ui.Successln("Output written to %s (%s format)", outputPath, format)
+	}
+
 	ui.Successln("Preview complete - no changes made")
 
 	return nil
 }
 
 // PostValidate validates markdown conversion without posting
-func (h *PublicationHandler) PostValidate(ctx context.Context, noteID int64, isDraft bool) error {
+func (h *PublicationHandler) PostValidate(ctx context.Context, noteID int64, isDraft bool, outputPath string, plaintext bool) error {
 	if !h.atproto.IsAuthenticated() {
 		return fmt.Errorf("not authenticated - run 'noteleaf pub auth' first")
 	}
···
 	ui.Infoln("  Title: %s", doc.Title)
 	ui.Infoln("  Blocks converted: %d", len(doc.Pages[0].Blocks))
 
+	if outputPath != "" {
+		if err := writeDocumentOutput(doc, note, outputPath, plaintext); err != nil {
+			return err
+		}
+		format := "JSON"
+		if plaintext {
+			format = "plaintext"
+		}
+		ui.Successln("Output written to %s (%s format)", outputPath, format)
+	}
+
 	return nil
 }
 
 // PatchPreview shows what would be patched without actually patching
-func (h *PublicationHandler) PatchPreview(ctx context.Context, noteID int64) error {
+func (h *PublicationHandler) PatchPreview(ctx context.Context, noteID int64, outputPath string, plaintext bool) error {
 	if !h.atproto.IsAuthenticated() {
 		return fmt.Errorf("not authenticated - run 'noteleaf pub auth' first")
 	}
···
 	if doc.PublishedAt != "" {
 		ui.Infoln("  PublishedAt: %s", doc.PublishedAt)
 	}
+
+	if outputPath != "" {
+		if err := writeDocumentOutput(doc, note, outputPath, plaintext); err != nil {
+			return err
+		}
+		format := "JSON"
+		if plaintext {
+			format = "plaintext"
+		}
+		ui.Successln("Output written to %s (%s format)", outputPath, format)
+	}
+
 	ui.Successln("Preview complete - no changes made")
 
 	return nil
 }
 
 // PatchValidate validates markdown conversion without patching
-func (h *PublicationHandler) PatchValidate(ctx context.Context, noteID int64) error {
+func (h *PublicationHandler) PatchValidate(ctx context.Context, noteID int64, outputPath string, plaintext bool) error {
 	if !h.atproto.IsAuthenticated() {
 		return fmt.Errorf("not authenticated - run 'noteleaf pub auth' first")
 	}
···
 	ui.Infoln("  Title: %s", doc.Title)
 	ui.Infoln("  RKey: %s", *note.LeafletRKey)
 	ui.Infoln("  Blocks converted: %d", len(doc.Pages[0].Blocks))
+
+	if outputPath != "" {
+		if err := writeDocumentOutput(doc, note, outputPath, plaintext); err != nil {
+			return err
+		}
+		format := "JSON"
+		if plaintext {
+			format = "plaintext"
+		}
+		ui.Successln("Output written to %s (%s format)", outputPath, format)
+	}
 
 	return nil
 }

internal/handlers/publication_test.go

···
 			handler := CreateHandler(t, NewPublicationHandler)
 			ctx := context.Background()
 
-			err := handler.PostPreview(ctx, 1, false)
+			err := handler.PostPreview(ctx, 1, false, "", false)
 			if err == nil {
 				t.Error("Expected error when not authenticated")
 			}
···
 				t.Fatalf("Failed to restore session: %v", err)
 			}
 
-			err = handler.PostPreview(ctx, 999, false)
+			err = handler.PostPreview(ctx, 999, false, "", false)
 			if err == nil {
 				t.Error("Expected error when note does not exist")
 			}
···
 				t.Fatalf("Failed to restore session: %v", err)
 			}
 
-			err = handler.PostPreview(ctx, id, false)
+			err = handler.PostPreview(ctx, id, false, "", false)
 			if err == nil {
 				t.Error("Expected error when note already published")
 			}
···
 				t.Fatalf("Failed to restore session: %v", err)
 			}
 
-			err = handler.PostPreview(ctx, id, false)
+			err = handler.PostPreview(ctx, id, false, "", false)
 			suite.AssertNoError(err, "preview should succeed")
 		})
 
···
 				t.Fatalf("Failed to restore session: %v", err)
 			}
 
-			err = handler.PostPreview(ctx, id, true)
+			err = handler.PostPreview(ctx, id, true, "", false)
 			suite.AssertNoError(err, "preview draft should succeed")
 		})
 	})
···
 			handler := CreateHandler(t, NewPublicationHandler)
 			ctx := context.Background()
 
-			err := handler.PostValidate(ctx, 1, false)
+			err := handler.PostValidate(ctx, 1, false, "", false)
 			if err == nil {
 				t.Error("Expected error when not authenticated")
 			}
···
 				t.Fatalf("Failed to restore session: %v", err)
 			}
 
-			err = handler.PostValidate(ctx, id, false)
+			err = handler.PostValidate(ctx, id, false, "", false)
 			suite.AssertNoError(err, "validation should succeed")
 		})
 	})
···
 			handler := CreateHandler(t, NewPublicationHandler)
 			ctx := context.Background()
 
-			err := handler.PatchPreview(ctx, 1)
+			err := handler.PatchPreview(ctx, 1, "", false)
 			if err == nil {
 				t.Error("Expected error when not authenticated")
 			}
···
 				t.Fatalf("Failed to restore session: %v", err)
 			}
 
-			err = handler.PatchPreview(ctx, 999)
+			err = handler.PatchPreview(ctx, 999, "", false)
 			if err == nil {
 				t.Error("Expected error when note does not exist")
 			}
···
 				t.Fatalf("Failed to restore session: %v", err)
 			}
 
-			err = handler.PatchPreview(ctx, id)
+			err = handler.PatchPreview(ctx, id, "", false)
 			if err == nil {
 				t.Error("Expected error when note not published")
 			}
···
 				t.Fatalf("Failed to restore session: %v", err)
 			}
 
-			err = handler.PatchPreview(ctx, id)
+			err = handler.PatchPreview(ctx, id, "", false)
 			suite.AssertNoError(err, "preview should succeed")
 		})
 	})
···
 			handler := CreateHandler(t, NewPublicationHandler)
 			ctx := context.Background()
 
-			err := handler.PatchValidate(ctx, 1)
+			err := handler.PatchValidate(ctx, 1, "", false)
 			if err == nil {
 				t.Error("Expected error when not authenticated")
 			}
···
 				t.Fatalf("Failed to restore session: %v", err)
 			}
 
-			err = handler.PatchValidate(ctx, id)
+			err = handler.PatchValidate(ctx, id, "", false)
 			suite.AssertNoError(err, "validation should succeed")
 		})
 	})

internal/ui/publication_list_adapter.go

···
 	return NewPublicationDataList(repo, opts, filter)
 }
 
-// formatPublicationForView formats a publication for display with glamour
-func formatPublicationForView(note *models.Note) string {
+// buildPublicationMarkdown builds markdown content for a publication without rendering
+func buildPublicationMarkdown(note *models.Note) string {
 	var content strings.Builder
 
 	content.WriteString("# " + note.Title + "\n\n")
···
 	if note.IsDraft {
 		status = "draft"
 	}
-	content.WriteString("**Status:** " + status + "\n")
+	content.WriteString("- **Status:** " + status + "\n")
 
 	if note.PublishedAt != nil {
-		content.WriteString("**Published:** " + note.PublishedAt.Format("2006-01-02 15:04") + "\n")
+		content.WriteString("- **Published:** " + note.PublishedAt.Format("2006-01-02 15:04") + "\n")
 	}
 
-	content.WriteString("**Modified:** " + note.Modified.Format("2006-01-02 15:04") + "\n")
+	content.WriteString("- **Modified:** " + note.Modified.Format("2006-01-02 15:04") + "\n")
 
 	if note.LeafletRKey != nil {
-		content.WriteString("**RKey:** `" + *note.LeafletRKey + "`\n")
+		content.WriteString("- **RKey:** `" + ObfuscateMiddle(*note.LeafletRKey, 3, 3) + "`\n")
 	}
 
 	if note.LeafletCID != nil {
-		content.WriteString("**CID:** `" + *note.LeafletCID + "`\n")
+		content.WriteString("- **CID:** `" + ObfuscateMiddle(*note.LeafletCID, 3, 3) + "`\n")
 	}
 
 	content.WriteString("\n---\n\n")
···
 		}
 	}
 
+	return content.String()
+}
+
+// formatPublicationForView formats a publication for display with glamour
+func formatPublicationForView(note *models.Note) string {
+	markdown := buildPublicationMarkdown(note)
+
 	renderer, err := glamour.NewTermRenderer(
-		glamour.WithAutoStyle(),
+		glamour.WithStandardStyle("tokyo-night"),
 		glamour.WithWordWrap(80),
 	)
 	if err != nil {
-		return content.String()
+		return markdown
 	}
 
-	rendered, err := renderer.Render(content.String())
+	rendered, err := renderer.Render(markdown)
 	if err != nil {
-		return content.String()
+		return markdown
 	}
 
 	return rendered

internal/ui/publication_list_adapter_test.go

···
 		}
 	})
 
-	t.Run("formatPublicationForView", func(t *testing.T) {
+	t.Run("buildPublicationMarkdown", func(t *testing.T) {
 		t.Run("formats published note with all metadata", func(t *testing.T) {
 			rkey := "test-rkey"
 			cid := "test-cid"
···
 				LeafletCID:  &cid,
 			}
 
-			result := formatPublicationForView(note)
+			result := buildPublicationMarkdown(note)
 
 			if !strings.Contains(result, "Test Article") {
-				t.Errorf("Formatted view should contain title\nGot: %s", result)
+				t.Error("Markdown should contain title")
 			}
 			if !strings.Contains(result, "published") {
-				t.Errorf("Formatted view should contain status 'published'\nGot: %s", result)
+				t.Error("Markdown should contain status 'published'")
 			}
 			if !strings.Contains(result, "2024-01-15") {
-				t.Errorf("Formatted view should contain published date\nGot: %s", result)
+				t.Error("Markdown should contain published date")
 			}
-			if !strings.Contains(result, "Modified") && !strings.Contains(result, "2024-01-16") {
-				t.Errorf("Formatted view should contain modified date\nGot: %s", result)
-			}
-			if !strings.Contains(result, "test-rkey") {
-				t.Error("Formatted view should contain rkey")
-			}
-			if !strings.Contains(result, "test-cid") {
-				t.Error("Formatted view should contain cid")
+			if !strings.Contains(result, "2024-01-16") {
+				t.Error("Markdown should contain modified date")
 			}
 		})
 
···
 				Modified: time.Date(2024, 1, 20, 14, 0, 0, 0, time.UTC),
 			}
 
-			result := formatPublicationForView(note)
+			result := buildPublicationMarkdown(note)
 
 			if !strings.Contains(result, "Draft Article") {
-				t.Error("Formatted view should contain title")
+				t.Error("Markdown should contain title")
 			}
 			if !strings.Contains(result, "draft") {
-				t.Error("Formatted view should contain status 'draft'")
+				t.Error("Markdown should contain status 'draft'")
 			}
 			if strings.Contains(result, "Published:") {
-				t.Error("Formatted draft view should not contain published date")
+				t.Error("Draft markdown should not contain published date")
 			}
 			if !strings.Contains(result, "2024-01-20 14:00") {
-				t.Error("Formatted view should contain modified date")
+				t.Error("Markdown should contain modified date")
 			}
 		})
 
···
 				Modified: time.Now(),
 			}
 
-			result := formatPublicationForView(note)
+			result := buildPublicationMarkdown(note)
 
 			if !strings.Contains(result, "Plain Content") {
-				t.Error("Formatted view should contain title")
+				t.Error("Markdown should contain title")
 			}
 			if !strings.Contains(result, "This content has no markdown header") {
-				t.Error("Formatted view should contain full content")
+				t.Error("Markdown should contain full content")
 			}
 		})
 
···
 				Modified: time.Now(),
 			}
 
-			result := formatPublicationForView(note)
+			result := buildPublicationMarkdown(note)
 
 			titleCount := strings.Count(result, "Article Title")
 			if titleCount < 1 {
-				t.Error("Formatted view should contain title at least once")
+				t.Error("Markdown should contain title at least once")
 			}
 			if !strings.Contains(result, "Content after title") {
-				t.Error("Formatted view should contain content after title")
+				t.Error("Markdown should contain content after title")
 			}
 		})
 	})

internal/ui/publication_view.go

···
 	"fmt"
 	"io"
 	"os"
-	"strings"
+	"unicode/utf8"
 
 	"github.com/charmbracelet/bubbles/help"
 	"github.com/charmbracelet/bubbles/key"
···
 	return lipgloss.JoinVertical(lipgloss.Left, title, "", content, "", help)
 }
 
-// buildPublicationMarkdown creates the markdown content for rendering
-func buildPublicationMarkdown(note *models.Note) string {
-	var content strings.Builder
-
-	content.WriteString("# " + note.Title + "\n\n")
-
-	status := "published"
-	if note.IsDraft {
-		status = "draft"
-	}
-	content.WriteString("**Status:** " + status + "\n")
-
-	if note.PublishedAt != nil {
-		content.WriteString("**Published:** " + note.PublishedAt.Format("2006-01-02 15:04") + "\n")
-	}
-
-	content.WriteString("**Modified:** " + note.Modified.Format("2006-01-02 15:04") + "\n")
-
-	if note.LeafletRKey != nil {
-		content.WriteString("**RKey:** `" + *note.LeafletRKey + "`\n")
-	}
-
-	if note.LeafletCID != nil {
-		content.WriteString("**CID:** `" + *note.LeafletCID + "`\n")
-	}
-
-	content.WriteString("\n---\n\n")
-
-	noteContent := strings.TrimSpace(note.Content)
-	if !strings.HasPrefix(noteContent, "# ") {
-		content.WriteString(noteContent)
-	} else {
-		lines := strings.Split(noteContent, "\n")
-		if len(lines) > 1 {
-			content.WriteString(strings.Join(lines[1:], "\n"))
-		}
-	}
-
-	return content.String()
-}
-
 // formatPublicationContent renders markdown with glamour for viewport display
 func formatPublicationContent(note *models.Note) (string, error) {
 	markdown := buildPublicationMarkdown(note)
 
 	renderer, err := glamour.NewTermRenderer(
 		glamour.WithAutoStyle(),
-		glamour.WithWordWrap(80),
+		glamour.WithStandardStyle("tokyo-night"),
+		glamour.WithPreservedNewLines(),
+		glamour.WithWordWrap(79),
 	)
 	if err != nil {
 		return markdown, fmt.Errorf("failed to create renderer: %w", err)
···
 	fmt.Fprint(pv.opts.Output, content)
 	return nil
 }
+
+// ObfuscateMiddle returns a string where the middle portion is replaced by "..."
+// TODO: move to package utils or shared
+func ObfuscateMiddle(s string, left, right int) string {
+	if s == "" {
+		return s
+	}
+	if left < 0 {
+		left = 0
+	}
+	if right < 0 {
+		right = 0
+	}
+
+	n := utf8.RuneCountInString(s)
+	if left+right >= n {
+		return s
+	}
+
+	var (
+		prefixRunes = make([]rune, 0, left)
+		suffixRunes = make([]rune, 0, right)
+	)
+	i := 0
+	for _, r := range s {
+		if i >= left {
+			break
+		}
+		prefixRunes = append(prefixRunes, r)
+		i++
+	}
+
+	if right > 0 {
+		allRunes := []rune(s)
+		start := max(n-right, 0)
+		suffixRunes = append(suffixRunes, allRunes[start:]...)
+	}
+
+	const repl = "..."
+	if right == 0 {
+		return string(prefixRunes) + repl
+	}
+	return string(prefixRunes) + repl + string(suffixRunes)
+}

internal/ui/publication_view_test.go

···
 
 			output := buf.String()
 
-			if !strings.Contains(output, "Test Publication") {
+			if !strings.Contains(output, "Test") || !strings.Contains(output, "Publication") {
 				t.Error("Note title not displayed")
 			}
 			if !strings.Contains(output, "published") {
···
 			if !strings.Contains(output, "RKey:") {
 				t.Error("RKey not displayed")
 			}
-			if !strings.Contains(output, "test-rkey-123") {
+			if !strings.Contains(output, "tes") || !strings.Contains(output, "123") {
 				t.Error("RKey value not displayed")
 			}
 			if !strings.Contains(output, "CID:") {
 				t.Error("CID not displayed")
 			}
-			if !strings.Contains(output, "test-cid-456") {
+			if !strings.Contains(output, "tes") || !strings.Contains(output, "456") {
 				t.Error("CID value not displayed")
 			}
-			if !strings.Contains(output, "This is the content") {
+			if !strings.Contains(output, "This") || !strings.Contains(output, "content") {
 				t.Error("Note content not displayed")
 			}
 		})
···
 
 			output := buf.String()
 
-			if !strings.Contains(output, "Minimal Note") {
+			if !strings.Contains(output, "Minimal") || !strings.Contains(output, "Note") {
 				t.Error("Note title not displayed")
 			}
-			if !strings.Contains(output, "Simple content") {
+			if !strings.Contains(output, "Simple") || !strings.Contains(output, "content") {
 				t.Error("Note content not displayed")
 			}
 			if !strings.Contains(output, "Modified:") {
···
 				"**Status:** published",
 				"**Published:**",
 				"**Modified:**",
-				"**RKey:** `test-rkey-123`",
-				"**CID:** `test-cid-456`",
+				"**RKey:**",
+				"**CID:**",
 				"---",
 				"This is the content",
 			}
···
 				t.Fatalf("formatPublicationContent failed: %v", err)
 			}
 
-			if !strings.Contains(content, "Test Publication") {
+			if !strings.Contains(content, "Test") || !strings.Contains(content, "Publication") {
 				t.Error("Formatted content should include note title")
 			}
 		})
···
 				t.Error("No output generated")
 			}
 
-			if !strings.Contains(output, note.Title) {
+			if !strings.Contains(output, "Test") || !strings.Contains(output, "Publication") {
 				t.Error("Note title not displayed")
 			}
-			if !strings.Contains(output, "This is the content") {
+			if !strings.Contains(output, "This") || !strings.Contains(output, "content") {
 				t.Error("Note content not displayed")
 			}
 		})