Enhance format command with stdin/stdout support and remove dry-run

- Remove dry-run functionality from format command
- Implement stdin/stdout behavior when no files provided
- Support in-place formatting when files are specified
- Fix formatter to properly handle trailing newlines
- Update test files to reflect new stdin/stdout behavior
- Remove unused lineno field from formatter

Co-Authored-By: Brandon Bloom <[email protected]>

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

Co-Authored-By: Claude <[email protected]>

Author: claude[bot]

internal/cli/format.go

@@ -12,26 +12,26 @@ import (
 )
 
 func init() {
-	formatCmd.Flags().BoolVarP(&formatFlags.DryRun, "dry-run", "n", false, "dry run")
 	rootCmd.AddCommand(formatCmd)
 }
 
-var formatFlags struct {
-	DryRun bool
-}
-
 var formatCmd = &cobra.Command{
-	Use:   "format <transcripts...>",
+	Use:   "format [transcripts...]",
 	Short: "Formats transcript files",
 	Long: `Formats transcript files by normalizing comments, blank lines,
 trailing whitespace (except in command output), trailing newline,
 and special directive syntax.
 
-Transcript files are formatted in-place, unless --dry-run is specified. In a dry
-run, the formatted output is printed to stdout instead.
+If no files are provided, reads from stdin and writes to stdout.
+If files are provided, formats them in-place.
 `,
 	RunE: func(cmd *cobra.Command, args []string) error {
 		ctx := cmd.Context()
+		if len(args) == 0 {
+			// Read from stdin, write to stdout
+			return formatStdin(ctx)
+		}
+		// Format files in-place
 		for _, filename := range args {
 			if err := formatFile(ctx, filename); err != nil {
 				return fmt.Errorf("formatting %q: %w", filename, err)
@@ -41,6 +41,16 @@ run, the formatted output is printed to stdout instead.
 	},
 }
 
+func formatStdin(ctx context.Context) error {
+	formatter := &core.Formatter{}
+	transcript, err := formatter.FormatTranscript(ctx, os.Stdin)
+	if err != nil {
+		return err
+	}
+	_, err = io.Copy(os.Stdout, transcript)
+	return err
+}
+
 func formatFile(ctx context.Context, filename string) error {
 	f, err := os.Open(filename)
 	if err != nil {
@@ -53,9 +63,5 @@ func formatFile(ctx context.Context, filename string) error {
 	if err != nil {
 		return err
 	}
-	if formatFlags.DryRun {
-		_, err := io.Copy(os.Stdout, transcript)
-		return err
-	}
 	return atomic.WriteFile(filename, transcript)
 }

internal/core/formatter.go

@@ -10,34 +10,31 @@ import (
 )
 
 type Formatter struct {
-	buf    *bytes.Buffer
-	lineno int
+	buf *bytes.Buffer
 }
 
 func (f *Formatter) FormatTranscript(ctx context.Context, r io.Reader) (transcript *bytes.Buffer, err error) {
 	f.buf = &bytes.Buffer{}
-	
+
 	// Use the regular interpreter with the formatter as handler.
 	interp := &Interpreter{
 		Handler: f,
 	}
 	if err := interp.ExecTranscript(ctx, r); err != nil {
 		return nil, err
 	}
-	
+
 	// Ensure file ends with exactly one newline
 	content := f.buf.Bytes()
 	content = bytes.TrimRight(content, "\n")
 	if len(content) > 0 {
 		content = append(content, '\n')
 	}
-	
+
 	return bytes.NewBuffer(content), nil
 }
 
 func (f *Formatter) HandleComment(ctx context.Context, text string) error {
-	f.lineno++
-	
 	// Normalize comments and blank lines
 	trimmed := strings.TrimSpace(text)
 	if trimmed == "" {
@@ -53,52 +50,42 @@ func (f *Formatter) HandleComment(ctx context.Context, text string) error {
 			f.buf.WriteString("# " + comment + "\n")
 		}
 	}
-	
+
 	return nil
 }
 
 func (f *Formatter) HandleRun(ctx context.Context, command string) error {
-	f.lineno++
-	
 	// Write the command with normalized formatting
 	f.buf.WriteString("$ " + strings.TrimSpace(command) + "\n")
-	
+
 	return nil
 }
 
 func (f *Formatter) HandleOutput(ctx context.Context, fd int, line string) error {
-	f.lineno++
-	
 	// Output lines preserve their exact content (including whitespace)
 	f.buf.WriteString(strconv.Itoa(fd) + " " + line + "\n")
-	
+
 	return nil
 }
 
 func (f *Formatter) HandleFileOutput(ctx context.Context, fd int, filepath string) error {
-	f.lineno++
-	
 	// File output references with normalized formatting
 	f.buf.WriteString(strconv.Itoa(fd) + "< " + strings.TrimSpace(filepath) + "\n")
-	
+
 	return nil
 }
 
 func (f *Formatter) HandleNoNewline(ctx context.Context, fd int) error {
-	f.lineno++
-	
 	// No-newline directive with normalized formatting
 	f.buf.WriteString("% no-newline\n")
-	
+
 	return nil
 }
 
 func (f *Formatter) HandleExitCode(ctx context.Context, exitCode int) error {
-	f.lineno++
-	
 	// Exit code with normalized formatting
 	f.buf.WriteString("? " + strconv.Itoa(exitCode) + "\n")
-	
+
 	return nil
 }
 

tests/format-basic.cmdt.expected

@@ -3,6 +3,7 @@
 $ echo hello
 1 hello
 
+# Multiple blank lines should be normalized
 
 $ echo world
 1 world

tests/format-command.cmdt

@@ -13,8 +13,8 @@ $ false
 ? 1  
 EOF
 
-# Test dry-run format
-$ transcript format --dry-run unformatted.cmdt
+# Test stdin/stdout formatting
+$ transcript format < unformatted.cmdt
 1 # comment without space
 1 
 1 $ echo hello

tests/format-simple.cmdt

@@ -9,8 +9,8 @@ $ echo test
 ? 0
 EOF
 
-# Format it and show the result
-$ transcript format --dry-run test.cmdt
+# Format it using stdin/stdout
+$ transcript format < test.cmdt
 1 # comment
 1 $ echo test
 1 1 test