Story 7.6: Starship-compatible format field (#56) (#63)

* Story 7.6: Starship-compatible format field with $line_break and styled spans (#56)

Add `format` field to CshipConfig supporting Starship-style format strings
with `$line_break` for multi-row output and `[content](style)` ANSI spans.
Fix parse_line to scan for both `[` and `$` simultaneously, preventing
styled spans after literal text from being silently eaten as plain text.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Fix: stop $token name parser at '[' to prevent absorbing adjacent styled spans

Without this, $cship.model[sep](fg:red) (no space) would consume the entire
[sep](fg:red) as part of the token name, silently dropping the styled span.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: stephenleo

src/config.rs

@@ -6,6 +6,9 @@ pub struct CshipConfig {
     /// `lines` array — each element is a format string for one statusline row.
     /// Example: `["$cship.model $git_branch", "$cship.cost"]`
     pub lines: Option<Vec<String>>,
+    /// Starship-compatible top-level format string. Split on `$line_break` to produce
+    /// multiple rows. Takes priority over `lines` when both are set.
+    pub format: Option<String>,
     /// Configuration for the `[cship.model]` section.
     pub model: Option<ModelConfig>,
     pub cost: Option<CostConfig>,

src/main.rs

@@ -69,7 +69,7 @@ fn main() {
             // Render and emit — main.rs is the SOLE owner of stdout.
             // println! is the ONLY stdout write in the rendering pipeline.
             let lines = cfg.lines.as_deref().unwrap_or(&[]);
-            if !lines.is_empty() {
+            if cfg.format.is_some() || !lines.is_empty() {
                 let output = cship::renderer::render(lines, &ctx, &cfg);
                 if !output.is_empty() {
                     println!("{output}");

src/renderer.rs

@@ -5,6 +5,7 @@ enum Token {
     Native(String),
     Passthrough(String),
     Literal(String), // bare text preserved verbatim
+    StyledSpan { content: String, style: String },
 }
 
 fn parse_line(line: &str) -> Vec<Token> {
@@ -14,31 +15,78 @@ fn parse_line(line: &str) -> Vec<Token> {
     while pos < line.len() {
         let remaining = &line[pos..];
 
-        if let Some(dollar_pos) = remaining.find('$') {
-            // Text before the '$' token is a literal (if non-empty)
-            if dollar_pos > 0 {
-                tokens.push(Token::Literal(remaining[..dollar_pos].to_string()));
+        // Check for styled span: [content](style) — only when '[' is at current position
+        if let Some(after_bracket) = remaining.strip_prefix('[') {
+            if let Some(close_bracket_offset) = after_bracket.find("](") {
+                let content = &after_bracket[..close_bracket_offset];
+                let after_open_paren = &after_bracket[close_bracket_offset + 2..]; // skip "]("
+                if let Some(close_paren) = after_open_paren.find(')') {
+                    let style = &after_open_paren[..close_paren];
+                    tokens.push(Token::StyledSpan {
+                        content: content.to_string(),
+                        style: style.to_string(),
+                    });
+                    // advance: 1 ('[') + close_bracket_offset + 2 ('](') + close_paren + 1 (')')
+                    pos += 1 + close_bracket_offset + 2 + close_paren + 1;
+                    continue;
+                }
+            }
+            // No matching ](...) found — emit literal "[" and advance one char
+            tokens.push(Token::Literal("[".to_string()));
+            pos += 1;
+            continue;
+        }
+
+        // Find next special character: '$' or '[' — process whichever comes first
+        let next_dollar = remaining.find('$');
+        let next_bracket = remaining.find('[');
+        let next_pos = match (next_dollar, next_bracket) {
+            (Some(d), Some(b)) => Some(d.min(b)),
+            (Some(d), None) => Some(d),
+            (None, Some(b)) => Some(b),
+            (None, None) => None,
+        };
+
+        match next_pos {
+            Some(special_pos) if special_pos > 0 => {
+                // Literal text before the next special character
+                tokens.push(Token::Literal(remaining[..special_pos].to_string()));
+                pos += special_pos;
+                // Re-enter loop — next iteration handles '[' or '$' at position 0
             }
-            // Read the token name (from after '$' to next whitespace or end)
-            let after_dollar = &remaining[dollar_pos + 1..];
-            let name_end = after_dollar
-                .find(char::is_whitespace)
-                .unwrap_or(after_dollar.len());
-            let name = &after_dollar[..name_end];
-            if !name.is_empty() {
-                if name.starts_with("cship.") {
-                    tokens.push(Token::Native(name.to_string()));
-                } else {
-                    tokens.push(Token::Passthrough(name.to_string()));
+            Some(_) => {
+                // special_pos == 0 and not '[' (handled above) → must be '$'
+                let after_dollar = &remaining[1..];
+                let name_end = after_dollar
+                    .find(|c: char| c.is_whitespace() || c == '[')
+                    .unwrap_or(after_dollar.len());
+                let name = &after_dollar[..name_end];
+                if !name.is_empty() {
+                    if name == "fill" {
+                        // $fill is deferred (future $cship.flex feature) — emit empty, warn once
+                        static FILL_WARNED: std::sync::atomic::AtomicBool =
+                            std::sync::atomic::AtomicBool::new(false);
+                        if !FILL_WARNED.swap(true, std::sync::atomic::Ordering::Relaxed) {
+                            tracing::warn!(
+                                "cship: $fill is not yet supported (deferred to $cship.flex); rendering as empty"
+                            );
+                        }
+                        tokens.push(Token::Literal(String::new()));
+                    } else if name.starts_with("cship.") {
+                        tokens.push(Token::Native(name.to_string()));
+                    } else {
+                        tokens.push(Token::Passthrough(name.to_string()));
+                    }
                 }
+                pos += 1 + name_end;
             }
-            pos += dollar_pos + 1 + name_end;
-        } else {
-            // No more '$' — remainder is all literal text
-            if !remaining.is_empty() {
-                tokens.push(Token::Literal(remaining.to_string()));
+            None => {
+                // No more special characters — remainder is all literal text
+                if !remaining.is_empty() {
+                    tokens.push(Token::Literal(remaining.to_string()));
+                }
+                break;
             }
-            break;
         }
     }
 
@@ -63,14 +111,32 @@ fn render_line(line: &str, ctx: &Context, cfg: &CshipConfig) -> String {
             Token::Literal(text) => {
                 parts.push(text);
             }
+            Token::StyledSpan { content, style } => {
+                parts.push(crate::ansi::apply_style(&content, Some(&style)));
+            }
         }
     }
 
     parts.join("") // No separator — spacing is encoded in Literal tokens
 }
 
 pub fn render(lines: &[String], ctx: &Context, cfg: &CshipConfig) -> String {
-    lines
+    // cfg.format takes priority over lines; split on "$line_break" to produce rows
+    let owned_lines: Vec<String>;
+    let effective_lines: &[String] = if let Some(format_str) = &cfg.format {
+        if !lines.is_empty() {
+            tracing::warn!("cship: format field is set — ignoring lines config");
+        }
+        owned_lines = format_str
+            .split("$line_break")
+            .map(|s| s.to_string())
+            .collect();
+        &owned_lines
+    } else {
+        lines
+    };
+
+    effective_lines
         .iter()
         .map(|line| render_line(line, ctx, cfg))
         .filter(|line| !line.is_empty())
@@ -114,6 +180,90 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_parse_line_styled_span_with_content() {
+        let tokens = parse_line("[text](bold green)");
+        assert_eq!(tokens.len(), 1);
+        assert!(
+            matches!(&tokens[0], Token::StyledSpan { content, style } if content == "text" && style == "bold green")
+        );
+    }
+
+    #[test]
+    fn test_parse_line_empty_styled_span() {
+        let tokens = parse_line("[](fg:#3d414a bg:#5f6366)");
+        assert_eq!(tokens.len(), 1);
+        assert!(
+            matches!(&tokens[0], Token::StyledSpan { content, style } if content.is_empty() && style == "fg:#3d414a bg:#5f6366")
+        );
+    }
+
+    #[test]
+    fn test_parse_line_unclosed_bracket_literal() {
+        let tokens = parse_line("[note:");
+        // "[" emitted as Literal, then "note:" as Literal
+        assert_eq!(tokens.len(), 2);
+        assert!(matches!(&tokens[0], Token::Literal(t) if t == "["));
+        assert!(matches!(&tokens[1], Token::Literal(t) if t == "note:"));
+    }
+
+    #[test]
+    fn test_parse_line_mixed_span_and_native() {
+        let tokens = parse_line("[bold](bold) $cship.model");
+        assert_eq!(tokens.len(), 3);
+        assert!(
+            matches!(&tokens[0], Token::StyledSpan { content, style } if content == "bold" && style == "bold")
+        );
+        assert!(matches!(&tokens[1], Token::Literal(t) if t == " "));
+        assert!(matches!(&tokens[2], Token::Native(n) if n == "cship.model"));
+    }
+
+    #[test]
+    fn test_parse_line_spaces_styled_span() {
+        // AC6: two spaces with foreground color
+        let tokens = parse_line("[  ](fg:#ffc878)");
+        assert_eq!(tokens.len(), 1);
+        assert!(
+            matches!(&tokens[0], Token::StyledSpan { content, style } if content == "  " && style == "fg:#ffc878")
+        );
+    }
+
+    #[test]
+    fn test_parse_line_styled_span_after_literal_text() {
+        // Regression: styled spans preceded by literal text must still be parsed
+        let tokens = parse_line("prefix [text](bold green)");
+        assert_eq!(tokens.len(), 2);
+        assert!(matches!(&tokens[0], Token::Literal(t) if t == "prefix "));
+        assert!(
+            matches!(&tokens[1], Token::StyledSpan { content, style } if content == "text" && style == "bold green")
+        );
+    }
+
+    #[test]
+    fn test_parse_line_styled_span_adjacent_to_token_no_space() {
+        // Regression: $token[span](style) without space must not absorb '[' into token name
+        let tokens = parse_line("$cship.model[sep](fg:red)");
+        assert_eq!(tokens.len(), 2);
+        assert!(matches!(&tokens[0], Token::Native(n) if n == "cship.model"));
+        assert!(
+            matches!(&tokens[1], Token::StyledSpan { content, style } if content == "sep" && style == "fg:red")
+        );
+    }
+
+    #[test]
+    fn test_parse_line_styled_span_after_native_token() {
+        // Regression: styled span after $token must be parsed (not eaten as literal)
+        let tokens = parse_line("$cship.model [sep](fg:red) $cship.cost");
+        assert_eq!(tokens.len(), 5);
+        assert!(matches!(&tokens[0], Token::Native(n) if n == "cship.model"));
+        assert!(matches!(&tokens[1], Token::Literal(t) if t == " "));
+        assert!(
+            matches!(&tokens[2], Token::StyledSpan { content, style } if content == "sep" && style == "fg:red")
+        );
+        assert!(matches!(&tokens[3], Token::Literal(t) if t == " "));
+        assert!(matches!(&tokens[4], Token::Native(n) if n == "cship.cost"));
+    }
+
     #[test]
     fn test_render_empty_lines_is_empty() {
         let ctx = Context::default();
@@ -148,4 +298,48 @@ mod tests {
         let result = render_line("in: $cship.context_window.total_input_tokens", &ctx, &cfg);
         assert_eq!(result, "in: 15234");
     }
+
+    #[test]
+    fn test_render_format_field_line_break() {
+        let ctx = Context::default();
+        let cfg = CshipConfig {
+            format: Some("line1$line_breakline2".to_string()),
+            ..Default::default()
+        };
+        let result = render(&[], &ctx, &cfg);
+        assert_eq!(result, "line1\nline2");
+    }
+
+    #[test]
+    fn test_render_format_takes_priority_over_lines() {
+        let ctx = Context::default();
+        let cfg = CshipConfig {
+            format: Some("from_format".to_string()),
+            lines: Some(vec!["from_lines".to_string()]),
+            ..Default::default()
+        };
+        let lines = cfg.lines.as_deref().unwrap_or(&[]);
+        let result = render(lines, &ctx, &cfg);
+        assert_eq!(result, "from_format");
+    }
+
+    #[test]
+    fn test_render_lines_unchanged_when_no_format() {
+        let ctx = Context::default();
+        let cfg = CshipConfig {
+            lines: Some(vec!["hello".to_string()]),
+            ..Default::default()
+        };
+        let lines = cfg.lines.as_deref().unwrap_or(&[]);
+        let result = render(lines, &ctx, &cfg);
+        assert_eq!(result, "hello");
+    }
+
+    #[test]
+    fn test_render_fill_token_renders_empty() {
+        let ctx = Context::default();
+        let cfg = CshipConfig::default();
+        let result = render_line("$fill", &ctx, &cfg);
+        assert_eq!(result, "");
+    }
 }

tests/cli.rs

@@ -966,3 +966,26 @@ fn test_literal_text_in_lines_preserved() {
         .success()
         .stdout(predicate::str::contains("in: 15234"));
 }
+
+// ── Story 7.6: Starship-compatible format field integration tests ──────────
+
+#[test]
+fn test_format_field_line_break_produces_two_rows() {
+    let json = std::fs::read_to_string("tests/fixtures/sample_input_full.json").unwrap();
+    // format_line_break.toml: format = "$cship.model$line_break$cship.model"
+    let output = cship()
+        .args(["--config", "tests/fixtures/format_line_break.toml"])
+        .write_stdin(json)
+        .output()
+        .unwrap();
+    assert!(output.status.success());
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let lines: Vec<&str> = stdout.trim_end_matches('\n').split('\n').collect();
+    assert_eq!(
+        lines.len(),
+        2,
+        "expected 2 lines from format with $line_break; got: {stdout:?}"
+    );
+    assert!(lines[0].contains("Opus"), "line 0: {}", lines[0]);
+    assert!(lines[1].contains("Opus"), "line 1: {}", lines[1]);
+}

tests/fixtures/format_line_break.toml

@@ -0,0 +1,2 @@
+[cship]
+format = "$cship.model$line_break$cship.model"