feat(tty): support DEC auto wrap mode (#18)

Author: tonyfettes

README.md

@@ -36,8 +36,8 @@ Use `Tty` when an operation needs a real terminal handle:
 - terminal events: `Tty::read_event`
 - output commands: cursor movement/visibility, line erase, scroll margins,
   reverse index, alternate screen, bracketed paste mode, SGR mouse tracking,
-  focus tracking, foreground/background colors, text attributes, and style
-  reset
+  focus tracking, DEC auto wrap mode, foreground/background colors, text
+  attributes, and style reset
 
 Raw file and stdio byte I/O should use `moonbitlang/async/fs` and
 `moonbitlang/async/stdio` directly. The root package does not wrap them as

docs/architecture.md

@@ -43,6 +43,7 @@ operations:
   through `Tty`
 - bracketed paste mode helpers through `Tty`
 - focus tracking mode helpers through `Tty`
+- DEC auto wrap mode helpers through `Tty`
 - terminal state operations such as `Tty::get_state`, `Tty::set_state`, and raw
   mode helpers through `Tty`
 
@@ -70,6 +71,7 @@ It should:
 - construct screen mode sequences such as alternate-screen enter/leave
 - construct bracketed paste enable/disable sequences
 - construct focus tracking enable/disable sequences
+- construct DEC auto wrap enable/disable sequences
 - construct scrolling-margin and reverse-index sequences
 - construct low-level SGR sequences and fixed SGR attribute bytes
 - document the standard or terminal family each sequence comes from

docs/plan.md

@@ -53,6 +53,7 @@ This board tracks implementation direction for `moonbit-community/tty`. Use
 | TTY-17 | done | Windows controlling console open | `docs/plans/2026-05-26-windows-tty-open.md`, root package | `Tty::open` uses Windows console devices instead of `/dev/tty` while keeping the public API unchanged | `moon fmt`, `moon check`, `moon test .`, `moon test`, `moon info`, `moon run tests/open` |
 | TTY-18 | done | Windows output VT mode during raw sessions | `docs/plans/2026-05-27-windows-output-vt-mode.md`, root package | Windows raw sessions enable and restore output VT processing plus delayed wrap while keeping public API unchanged | `moon fmt`, `moon check`, `moon test .`, `moon test`, `moon info`, Windows manual examples |
 | TTY-19 | done | OSC dynamic color queries | `docs/plans/2026-05-27-osc-dynamic-colors.md`, `color/`, `internal/vt/`, `internal/input/`, root package | root `Tty` can query default foreground, default background, and cursor colors while preserving interleaved input | `moon fmt`, `moon test color`, `moon test internal/vt`, `moon test internal/input`, `moon test .`, `moon test`, `moon check`, `moon info`, `git diff --check` |
+| TTY-20 | done | DEC auto wrap mode commands | `docs/plans/2026-05-29-decawm-auto-wrap.md`, `internal/vt/`, root package | root `Tty` can enable and disable DECAWM without adding terminal state or a capability query | `moon fmt`, `moon test internal/vt`, `moon test .`, `moon check`, `moon info`, `git diff --check` |
 | MVP-2 | done | queued input and shell commands in agent demo | `docs/plans/2026-05-21-agent-queued-shell.md`, `examples/agent` | `Tab` queues input for delayed submission and `!cmd` runs through `moonbitlang/async/process` without background tasks writing directly to tty | `moon fmt`, `moon check examples/agent`, `moon test examples/agent`, `moon check`, `moon test`, `moon info`, `git diff --check` |
 
 ## Current Rules

docs/plans/2026-05-29-decawm-auto-wrap.md

@@ -0,0 +1,96 @@
+# DECAWM Auto Wrap Mode
+
+## Goal
+
+Expose DEC auto wrap mode (DECAWM, private mode 7) through the root `Tty`
+command surface, without adding terminal-emulator state or capability probing.
+
+## Status
+
+Done.
+
+## Context And Decisions
+
+- DECAWM is controlled with DEC private mode 7:
+  - enable: `CSI ? 7 h`
+  - disable: `CSI ? 7 l`
+- This is an output-side terminal mode switch. It does not affect the input
+  event model.
+- Do not add a scoped `with_auto_wrap` helper. The package does not track the
+  previous terminal mode state, and forcing a fixed restore value could undo a
+  caller or terminal preference.
+- Unsupported terminals can ignore the mode switch; no support query is added.
+
+## References Or Standards
+
+- DEC private mode 7, commonly named DECAWM.
+
+## Target Files
+
+- `internal/vt/screen.mbt`
+- `internal/vt/screen_test.mbt`
+- `style.mbt`
+- `tty_wbtest.mbt`
+- `README.md`
+- `docs/architecture.md`
+- `docs/plan.md`
+- generated `.mbti` files from `moon info`
+
+## Public API Changes
+
+Root package additions:
+
+- `Tty::enable_auto_wrap(Self) -> Unit`
+- `Tty::disable_auto_wrap(Self) -> Unit`
+
+Internal VT package additions:
+
+- `enable_auto_wrap : Bytes`
+- `disable_auto_wrap : Bytes`
+
+No new public type, parser state, input event, platform backend, or capability
+query is proposed.
+
+## Invariants
+
+- `Tty` remains the public output-command surface.
+- `internal/vt` remains byte-sequence-only and does not own output streams.
+- The package does not remember or infer terminal auto-wrap state.
+- DECAWM support does not add a screen model, renderer, layout layer, or
+  terminal-emulator state.
+
+## Acceptance Criteria
+
+- Internal VT helpers emit `CSI ? 7 h` and `CSI ? 7 l`.
+- Root command helpers write the same bytes through `Tty`.
+- Generated `.mbti` diffs contain only the intended API additions.
+
+## Validation Commands
+
+- `moon fmt` passed.
+- `moon test internal/vt` passed: 17 tests.
+- `moon test .` passed: 24 tests.
+- `moon check` passed.
+- `moon info` passed and regenerated intended `.mbti` entries.
+- `git diff --check` passed.
+
+## Public API Audit
+
+- Root `Tty` now exposes `enable_auto_wrap` and `disable_auto_wrap` for callers
+  that need to control DECAWM directly.
+- Internal VT exposes `enable_auto_wrap` and `disable_auto_wrap` byte constants
+  for root command methods.
+- No public parser state, platform handle, input event, wrapper type, mutable
+  field, or terminal state model was added.
+- The generated `.mbti` diff was reviewed and contains only the intended root
+  and internal VT additions.
+
+## Result Notes
+
+- Added fixed DECAWM byte constants and root write-through helpers.
+- Added internal VT sequence tests and root pipe-backed command tests.
+- Updated README, architecture notes, and the execution board.
+
+## Open Questions
+
+- None.

internal/vt/pkg.generated.mbti

@@ -20,6 +20,8 @@ pub fn cursor_prev_line(Int) -> Bytes
 
 pub fn cursor_up(Int) -> Bytes
 
+pub let disable_auto_wrap : Bytes
+
 pub let disable_bracketed_paste : Bytes
 
 pub let disable_focus_tracking : Bytes
@@ -32,6 +34,8 @@ pub let disable_mouse_motion : Bytes
 
 pub let disable_sgr_mouse : Bytes
 
+pub let enable_auto_wrap : Bytes
+
 pub let enable_bracketed_paste : Bytes
 
 pub let enable_focus_tracking : Bytes

internal/vt/screen.mbt

@@ -22,6 +22,14 @@ pub let enable_focus_tracking : Bytes = b"\x1b[?1004h"
 /// Disable focus tracking, xterm private mode 1004.
 pub let disable_focus_tracking : Bytes = b"\x1b[?1004l"
 
+///|
+/// Enable DEC auto wrap mode (DECAWM), DEC private mode 7.
+pub let enable_auto_wrap : Bytes = b"\x1b[?7h"
+
+///|
+/// Disable DEC auto wrap mode (DECAWM), DEC private mode 7.
+pub let disable_auto_wrap : Bytes = b"\x1b[?7l"
+
 ///|
 /// Query kitty keyboard protocol progressive enhancement flags.
 pub let query_keyboard_enhancement_flags : Bytes = b"\x1b[?u"

internal/vt/screen_test.mbt

@@ -16,6 +16,12 @@ test "focus tracking sequences" {
   @debug.assert_eq(@vt.disable_focus_tracking, b"\x1b[?1004l")
 }
 
+///|
+test "auto wrap mode sequences" {
+  @debug.assert_eq(@vt.enable_auto_wrap, b"\x1b[?7h")
+  @debug.assert_eq(@vt.disable_auto_wrap, b"\x1b[?7l")
+}
+
 ///|
 test "terminal response query sequences" {
   @debug.assert_eq(@vt.query_keyboard_enhancement_flags, b"\x1b[?u")

pkg.generated.mbti

@@ -53,9 +53,11 @@ pub fn Tty::close(Self) -> Unit
 pub async fn Tty::cursor_back(Self, Int) -> Unit
 pub async fn Tty::cursor_forward(Self, Int) -> Unit
 pub async fn Tty::cursor_up(Self, Int) -> Unit
+pub async fn Tty::disable_auto_wrap(Self) -> Unit
 pub async fn Tty::disable_bracketed_paste(Self) -> Unit
 pub async fn Tty::disable_focus_tracking(Self) -> Unit
 pub async fn Tty::disable_mouse(Self) -> Unit
+pub async fn Tty::enable_auto_wrap(Self) -> Unit
 pub async fn Tty::enable_bracketed_paste(Self) -> Unit
 pub async fn Tty::enable_focus_tracking(Self) -> Unit
 pub async fn Tty::enable_mouse(Self, MouseTrackingMode) -> Unit

style.mbt

@@ -166,6 +166,18 @@ pub async fn Tty::disable_focus_tracking(self : Self) -> Unit {
   self.write(@vt.disable_focus_tracking)
 }
 
+///|
+/// Enable DEC auto wrap mode (DECAWM).
+pub async fn Tty::enable_auto_wrap(self : Self) -> Unit {
+  self.write(@vt.enable_auto_wrap)
+}
+
+///|
+/// Disable DEC auto wrap mode (DECAWM).
+pub async fn Tty::disable_auto_wrap(self : Self) -> Unit {
+  self.write(@vt.disable_auto_wrap)
+}
+
 ///|
 /// Run `f` with focus tracking enabled.
 pub async fn[T] Tty::with_focus_tracking(self : Self, f : async () -> T) -> T {

tty_wbtest.mbt

@@ -114,6 +114,15 @@ async test "pipe tty focus tracking commands write sequences" {
   inspect(output, content="\u{1B}[?1004h\u{1B}[?1004l")
 }
 
+///|
+async test "pipe tty auto wrap commands write sequences" {
+  let output = with_pipe_tty(b"", tty => {
+    tty.enable_auto_wrap()
+    tty.disable_auto_wrap()
+  })
+  inspect(output, content="\u{1B}[?7h\u{1B}[?7l")
+}
+
 ///|
 async test "pipe tty with focus tracking restores on success" {
   let output = with_pipe_tty(b"", tty => {