headson 0.6.2__tar.gz → 0.6.3__tar.gz

{headson-0.6.2 → headson-0.6.3}/Cargo.lock

@@ -298,7 +298,7 @@ dependencies = [
 
 [[package]]
 name = "headson"
-version = "0.6.2"
+version = "0.6.3"
 dependencies = [
  "anyhow",
  "assert_cmd",

{headson-0.6.2 → headson-0.6.3}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "headson"
-version = "0.6.2"
+version = "0.6.3"
 edition = "2024"
 description = "Budget‑constrained JSON preview renderer"
 readme = "README.md"

{headson-0.6.2 → headson-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: headson
-Version: 0.6.2
+Version: 0.6.3
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust
@@ -20,7 +20,7 @@ Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
   <br/>
 </p>
 
-Head/tail for JSON and YAML — but structure‑aware. Get a compact preview that shows both the shape and representative values of your data, all within a strict character budget.
+`heal`/`tail` for JSON, YAML - but structure‑aware. Get a compact preview that shows both the shape and representative values of your data, all within a strict character budget. (Just like `head`/`tail`, `headson` can also work with unstructured text files.)
 
 Available as:
 - CLI (see [Usage](#usage))
@@ -41,10 +41,11 @@ From source:
 ## Features
 
 - Budgeted output: specify exactly how much you want to see
-- Output formats: `auto | json | yaml`
+- Output formats: `auto | json | yaml | text`
   - Styles: `strict | default | detailed`
     - JSON family: `strict` → strict JSON, `default` → human‑friendly Pseudo, `detailed` → JS with inline comments
     - YAML: always YAML; `strict` has no comments, `default` uses “# …”, `detailed` uses “# N more …”
+    - Text: prints raw lines. In `default` style, omissions are shown as a single line `…`; in `detailed`, as `… N more lines …`. `strict` omits array‑level summaries.
 - Multiple inputs: preview many files at once with a shared or per‑file budget
 - Fast: processes gigabyte‑scale files in seconds (mostly disk‑bound)
 - Available as a CLI app and as a Python library
@@ -68,12 +69,12 @@ Common flags:
 
 - `-n, --budget <BYTES>`: per‑file output budget. For multiple inputs, default total budget is `<BYTES> * number_of_inputs`.
 - `-N, --global-budget <BYTES>`: total output budget across all inputs. With `--budget`, the effective total is the smaller of the two.
-- `-f, --format <auto|json|yaml>`: output format (default: `auto`).
-  - Auto: stdin → JSON family; filesets → per‑file based on extension (`.json` → JSON family, `.yaml`/`.yml` → YAML).
+- `-f, --format <auto|json|yaml|text>`: output format (default: `auto`).
+  - Auto: stdin → JSON family; filesets → per‑file based on extension (`.json` → JSON family, `.yaml`/`.yml` → YAML, unknown → Text).
 - `-t, --template <strict|default|detailed>`: output style (default: `default`).
   - JSON family: `strict` → strict JSON; `default` → Pseudo; `detailed` → JS with inline comments.
   - YAML: always YAML; style only affects comments (`strict` none, `default` “# …”, `detailed` “# N more …”).
-- `-i, --input-format <json|yaml>`: ingestion format (default: `json`). For filesets in `auto` format, ingestion is chosen by extensions.
+- `-i, --input-format <json|yaml|text>`: ingestion format (default: `json`). For filesets in `auto` format, ingestion is chosen by extensions.
 - `-m, --compact`: no indentation, no spaces, no newlines
 - `--no-newline`: single line output
 - `--no-space`: no space after `:` in objects
@@ -86,7 +87,8 @@ Notes:
 
 - Multiple inputs:
   - With newlines enabled, file sections are rendered with human‑readable headers. In compact/single‑line modes, headers are omitted.
-  - In `--format auto`, each file uses its own best format: JSON family for `.json`, YAML for `.yaml`/`.yml`.
+- In `--format auto`, each file uses its own best format: JSON family for `.json`, YAML for `.yaml`/`.yml`.
+  - Unknown extensions are treated as Text (raw lines) — safe for logs and `.txt` files.
   - `--global-budget` may truncate or omit entire files to respect the total budget.
   - The tool finds the largest preview that fits the budget; even if extremely tight, you still get a minimal, valid preview.
   - Directories and binary files are ignored; a notice is printed to stderr for each. Stdin reads the stream as‑is.
@@ -110,6 +112,25 @@ Quick one‑liners:
 
       headson -n 400 -f yaml -t detailed config.yaml
 
+### Text mode
+
+- Single file (auto):
+
+      headson -n 200 notes.txt
+
+- Force Text ingest/output (useful when mixing with other extensions):
+
+      headson -n 200 -i text -f text notes.txt
+
+- Many text files (fileset):
+
+      headson -n 800 -i text -f text logs/*.txt
+
+- Styles on Text:
+  - default: omission as a standalone `…` line.
+  - detailed: omission as `… N more lines …`.
+  - strict: no array‑level omission line (individual long lines may still truncate with `…`).
+
 Show help:
 
     headson --help
@@ -157,6 +178,7 @@ Regenerate locally:
 - Run: cargo make tapes
 - Outputs are written to docs/assets/tapes
 
+
 ## Python Bindings
 
 A thin Python extension module is available on PyPI as `headson`.

{headson-0.6.2 → headson-0.6.3}/README.md

@@ -6,7 +6,7 @@
   <br/>
 </p>
 
-Head/tail for JSON and YAML — but structure‑aware. Get a compact preview that shows both the shape and representative values of your data, all within a strict character budget.
+`heal`/`tail` for JSON, YAML - but structure‑aware. Get a compact preview that shows both the shape and representative values of your data, all within a strict character budget. (Just like `head`/`tail`, `headson` can also work with unstructured text files.)
 
 Available as:
 - CLI (see [Usage](#usage))
@@ -27,10 +27,11 @@ From source:
 ## Features
 
 - Budgeted output: specify exactly how much you want to see
-- Output formats: `auto | json | yaml`
+- Output formats: `auto | json | yaml | text`
   - Styles: `strict | default | detailed`
     - JSON family: `strict` → strict JSON, `default` → human‑friendly Pseudo, `detailed` → JS with inline comments
     - YAML: always YAML; `strict` has no comments, `default` uses “# …”, `detailed` uses “# N more …”
+    - Text: prints raw lines. In `default` style, omissions are shown as a single line `…`; in `detailed`, as `… N more lines …`. `strict` omits array‑level summaries.
 - Multiple inputs: preview many files at once with a shared or per‑file budget
 - Fast: processes gigabyte‑scale files in seconds (mostly disk‑bound)
 - Available as a CLI app and as a Python library
@@ -54,12 +55,12 @@ Common flags:
 
 - `-n, --budget <BYTES>`: per‑file output budget. For multiple inputs, default total budget is `<BYTES> * number_of_inputs`.
 - `-N, --global-budget <BYTES>`: total output budget across all inputs. With `--budget`, the effective total is the smaller of the two.
-- `-f, --format <auto|json|yaml>`: output format (default: `auto`).
-  - Auto: stdin → JSON family; filesets → per‑file based on extension (`.json` → JSON family, `.yaml`/`.yml` → YAML).
+- `-f, --format <auto|json|yaml|text>`: output format (default: `auto`).
+  - Auto: stdin → JSON family; filesets → per‑file based on extension (`.json` → JSON family, `.yaml`/`.yml` → YAML, unknown → Text).
 - `-t, --template <strict|default|detailed>`: output style (default: `default`).
   - JSON family: `strict` → strict JSON; `default` → Pseudo; `detailed` → JS with inline comments.
   - YAML: always YAML; style only affects comments (`strict` none, `default` “# …”, `detailed` “# N more …”).
-- `-i, --input-format <json|yaml>`: ingestion format (default: `json`). For filesets in `auto` format, ingestion is chosen by extensions.
+- `-i, --input-format <json|yaml|text>`: ingestion format (default: `json`). For filesets in `auto` format, ingestion is chosen by extensions.
 - `-m, --compact`: no indentation, no spaces, no newlines
 - `--no-newline`: single line output
 - `--no-space`: no space after `:` in objects
@@ -72,7 +73,8 @@ Notes:
 
 - Multiple inputs:
   - With newlines enabled, file sections are rendered with human‑readable headers. In compact/single‑line modes, headers are omitted.
-  - In `--format auto`, each file uses its own best format: JSON family for `.json`, YAML for `.yaml`/`.yml`.
+- In `--format auto`, each file uses its own best format: JSON family for `.json`, YAML for `.yaml`/`.yml`.
+  - Unknown extensions are treated as Text (raw lines) — safe for logs and `.txt` files.
   - `--global-budget` may truncate or omit entire files to respect the total budget.
   - The tool finds the largest preview that fits the budget; even if extremely tight, you still get a minimal, valid preview.
   - Directories and binary files are ignored; a notice is printed to stderr for each. Stdin reads the stream as‑is.
@@ -96,6 +98,25 @@ Quick one‑liners:
 
       headson -n 400 -f yaml -t detailed config.yaml
 
+### Text mode
+
+- Single file (auto):
+
+      headson -n 200 notes.txt
+
+- Force Text ingest/output (useful when mixing with other extensions):
+
+      headson -n 200 -i text -f text notes.txt
+
+- Many text files (fileset):
+
+      headson -n 800 -i text -f text logs/*.txt
+
+- Styles on Text:
+  - default: omission as a standalone `…` line.
+  - detailed: omission as `… N more lines …`.
+  - strict: no array‑level omission line (individual long lines may still truncate with `…`).
+
 Show help:
 
     headson --help
@@ -143,6 +164,7 @@ Regenerate locally:
 - Run: cargo make tapes
 - Outputs are written to docs/assets/tapes
 
+
 ## Python Bindings
 
 A thin Python extension module is available on PyPI as `headson`.

{headson-0.6.2 → headson-0.6.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "headson"
-version = "0.6.2"
+version = "0.6.3"
 description = "Budget‑constrained JSON preview renderer (Python bindings)"
 readme = "README.md"
 requires-python = ">=3.10"

{headson-0.6.2 → headson-0.6.3}/python/Cargo.lock

@@ -214,7 +214,7 @@ dependencies = [
 
 [[package]]
 name = "headson"
-version = "0.6.2"
+version = "0.6.3"
 dependencies = [
  "anyhow",
  "clap",
@@ -228,7 +228,7 @@ dependencies = [
 
 [[package]]
 name = "headson-python"
-version = "0.6.2"
+version = "0.6.3"
 dependencies = [
  "anyhow",
  "headson",

{headson-0.6.2 → headson-0.6.3}/python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "headson-python"
-version = "0.6.2"
+version = "0.6.3"
 edition = "2021"
 publish = false
 readme = "README.md"

{headson-0.6.2 → headson-0.6.3}/python/README.md

@@ -5,9 +5,9 @@ Minimal Python API for the `headson` preview renderer.
 API
 
 - `headson.summarize(text: str, *, format: str = "auto", style: str = "default", input_format: str = "json", character_budget: int | None = None, skew: str = "balanced") -> str`
-  - `format`: output format — `"auto" | "json" | "yaml"`.
+  - `format`: output format — `"auto" | "json" | "yaml" | "text"`.
   - `style`: output style — `"strict" | "default" | "detailed"`.
-  - `input_format`: ingestion format — `"json" | "yaml"`.
+  - `input_format`: ingestion format — `"json" | "yaml" | "text"`.
   - `character_budget`: maximum output size in characters (defaults to 500 if not set).
   - `skew`: one of `"balanced" | "head" | "tail"`.
     - `balanced` (default), `head` keeps first N, `tail` keeps last N. Display styles place omission markers accordingly; strict JSON remains unannotated.
@@ -36,6 +36,10 @@ print(headson.summarize(doc, format="yaml", style="default", input_format="yaml"
 print(headson.summarize(doc, format="yaml", style="detailed", input_format="yaml", character_budget=60))
 
 # Note: tail mode affects only display styles; strict JSON stays strict.
+
+# Text: render raw lines with omission markers depending on style
+text = "one\ntwo\nthree\n"
+print(headson.summarize(text, format="text", style="default", input_format="text", character_budget=10))
 ```
 
 Install for development:

{headson-0.6.2 → headson-0.6.3}/python/src/lib.rs

@@ -31,7 +31,11 @@ fn map_output_template(format: &str, style: Style) -> Result<OutputTemplate> {
         "auto" => Ok(map_json_template_for_style(style)), // stdin => JSON family
         "json" => Ok(map_json_template_for_style(style)),
         "yaml" | "yml" => Ok(OutputTemplate::Yaml),
-        other => bail!("unknown format: {} (expected 'auto' | 'json' | 'yaml')", other),
+        "text" => Ok(OutputTemplate::Text),
+        other => bail!(
+            "unknown format: {} (expected 'auto' | 'json' | 'yaml' | 'text')",
+            other
+        ),
     }
 }
 
@@ -107,14 +111,12 @@ fn summarize(
     let input = text.as_bytes().to_vec();
     py.detach(|| {
         match input_format.to_ascii_lowercase().as_str() {
-            "json" => headson_core::headson(input, &cfg, &prio, budget)
+            "json" => headson_core::headson(input, &cfg, &prio, budget).map_err(to_pyerr),
+            "yaml" | "yml" => headson_core::headson_yaml(input, &cfg, &prio, budget)
                 .map_err(to_pyerr),
-            "yaml" | "yml" => {
-                headson_core::headson_yaml(input, &cfg, &prio, budget)
-                    .map_err(to_pyerr)
-            }
+            "text" => headson_core::headson_text(input, &cfg, &prio, budget).map_err(to_pyerr),
             other => Err(to_pyerr(anyhow::anyhow!(
-                "unknown input_format: {} (expected 'json' | 'yaml')",
+                "unknown input_format: {} (expected 'json' | 'yaml' | 'text')",
                 other
             ))),
         }

headson-0.6.3/src/ingest/json.rs

@@ -0,0 +1,37 @@
+use anyhow::Result;
+
+use super::Ingest;
+use crate::order::PriorityConfig;
+use crate::utils::tree_arena::JsonTreeArena as TreeArena;
+
+/// JSON adapter for the ingest boundary. Delegates to the existing
+/// JSON builder to produce the neutral `TreeArena`.
+pub struct JsonIngest;
+
+impl Ingest for JsonIngest {
+    fn parse_one(bytes: Vec<u8>, cfg: &PriorityConfig) -> Result<TreeArena> {
+        crate::json_ingest::build_json_tree_arena_from_bytes(bytes, cfg)
+    }
+
+    fn parse_many(
+        inputs: Vec<(String, Vec<u8>)>,
+        cfg: &PriorityConfig,
+    ) -> Result<TreeArena> {
+        crate::json_ingest::build_json_tree_arena_from_many(inputs, cfg)
+    }
+}
+
+/// Convenience functions for the JSON ingest path.
+pub fn parse_json_one(
+    bytes: Vec<u8>,
+    cfg: &PriorityConfig,
+) -> Result<TreeArena> {
+    JsonIngest::parse_one(bytes, cfg)
+}
+
+pub fn parse_json_many(
+    inputs: Vec<(String, Vec<u8>)>,
+    cfg: &PriorityConfig,
+) -> Result<TreeArena> {
+    JsonIngest::parse_many(inputs, cfg)
+}

headson-0.6.3/src/ingest/mod.rs

@@ -0,0 +1,64 @@
+use anyhow::Result;
+
+use crate::order::PriorityConfig;
+use crate::utils::tree_arena::JsonTreeArena as TreeArena;
+
+/// Format-agnostic ingest boundary. Other formats can implement this trait
+/// to produce the neutral TreeArena without going through JSON first.
+pub trait Ingest {
+    fn parse_one(bytes: Vec<u8>, cfg: &PriorityConfig) -> Result<TreeArena>;
+    fn parse_many(
+        inputs: Vec<(String, Vec<u8>)>,
+        cfg: &PriorityConfig,
+    ) -> Result<TreeArena>;
+}
+
+// Submodules for per-format adapters
+pub mod json;
+pub mod text;
+pub mod yaml;
+
+// Re-export commonly used helpers for convenience (keep adapter types private)
+pub use json::{parse_json_many, parse_json_one};
+pub use text::{parse_text_many, parse_text_one};
+pub use yaml::{parse_yaml_many, parse_yaml_one};
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::order::NodeKind;
+
+    #[test]
+    fn parse_one_basic_shape() {
+        let arena = parse_json_one(
+            b"{\"a\":1}".to_vec(),
+            &PriorityConfig::new(usize::MAX, usize::MAX),
+        )
+        .unwrap();
+        assert!(
+            !arena.is_fileset,
+            "single input should not be marked fileset"
+        );
+        let root = arena.root_id;
+        assert_eq!(arena.nodes[root].kind, NodeKind::Object);
+        assert_eq!(arena.nodes[root].object_len.unwrap_or(1), 1);
+    }
+
+    #[test]
+    fn parse_many_sets_fileset_root() {
+        let inputs = vec![
+            ("a.json".to_string(), b"{}".to_vec()),
+            ("b.json".to_string(), b"[]".to_vec()),
+        ];
+        let arena = parse_json_many(
+            inputs,
+            &PriorityConfig::new(usize::MAX, usize::MAX),
+        )
+        .unwrap();
+        assert!(arena.is_fileset, "multi input should be marked fileset");
+        let root = arena.root_id;
+        assert_eq!(arena.nodes[root].kind, NodeKind::Object);
+        // Expect two top-level entries
+        assert_eq!(arena.nodes[root].object_len.unwrap_or(0), 2);
+    }
+}

headson-0.6.3/src/ingest/text.rs

@@ -0,0 +1,45 @@
+use anyhow::Result;
+
+use super::Ingest;
+use crate::order::PriorityConfig;
+use crate::utils::tree_arena::JsonTreeArena as TreeArena;
+
+/// Text adapter for the ingest boundary.
+///
+/// Behavior:
+/// - Decodes input as UTF-8 using `String::from_utf8_lossy`, which replaces
+///   any invalid UTF-8 byte sequences with the Unicode replacement character
+///   U+FFFD (this is what “lossy” means here).
+/// - Normalizes newlines to `\n`, splits into logical lines, and builds an
+///   array of string nodes.
+/// - For multi-file inputs, produces a fileset object where each value is the
+///   corresponding file’s array of lines.
+pub struct TextIngest;
+
+impl Ingest for TextIngest {
+    fn parse_one(bytes: Vec<u8>, cfg: &PriorityConfig) -> Result<TreeArena> {
+        crate::text_ingest::build_text_tree_arena_from_bytes(bytes, cfg)
+    }
+
+    fn parse_many(
+        inputs: Vec<(String, Vec<u8>)>,
+        cfg: &PriorityConfig,
+    ) -> Result<TreeArena> {
+        crate::text_ingest::build_text_tree_arena_from_many(inputs, cfg)
+    }
+}
+
+/// Convenience functions for the Text ingest path.
+pub fn parse_text_one(
+    bytes: Vec<u8>,
+    cfg: &PriorityConfig,
+) -> Result<TreeArena> {
+    TextIngest::parse_one(bytes, cfg)
+}
+
+pub fn parse_text_many(
+    inputs: Vec<(String, Vec<u8>)>,
+    cfg: &PriorityConfig,
+) -> Result<TreeArena> {
+    TextIngest::parse_many(inputs, cfg)
+}

headson-0.6.3/src/ingest/yaml.rs

@@ -0,0 +1,39 @@
+use anyhow::Result;
+
+use super::Ingest;
+use crate::order::PriorityConfig;
+use crate::utils::tree_arena::JsonTreeArena as TreeArena;
+
+/// YAML adapter for the ingest boundary. Parses YAML using `yaml-rust2`
+/// and builds the neutral `TreeArena`. Multi-document YAML in a single
+/// input is wrapped in an array; multi-file inputs produce a fileset
+/// object whose values may be arrays when a file contains multiple docs.
+pub struct YamlIngest;
+
+impl Ingest for YamlIngest {
+    fn parse_one(bytes: Vec<u8>, cfg: &PriorityConfig) -> Result<TreeArena> {
+        crate::yaml_ingest::build_yaml_tree_arena_from_bytes(bytes, cfg)
+    }
+
+    fn parse_many(
+        inputs: Vec<(String, Vec<u8>)>,
+        cfg: &PriorityConfig,
+    ) -> Result<TreeArena> {
+        crate::yaml_ingest::build_yaml_tree_arena_from_many(inputs, cfg)
+    }
+}
+
+/// Convenience functions for the YAML ingest path.
+pub fn parse_yaml_one(
+    bytes: Vec<u8>,
+    cfg: &PriorityConfig,
+) -> Result<TreeArena> {
+    YamlIngest::parse_one(bytes, cfg)
+}
+
+pub fn parse_yaml_many(
+    inputs: Vec<(String, Vec<u8>)>,
+    cfg: &PriorityConfig,
+) -> Result<TreeArena> {
+    YamlIngest::parse_many(inputs, cfg)
+}

{headson-0.6.2 → headson-0.6.3}/src/lib.rs

@@ -25,6 +25,7 @@ mod ingest;
 mod json_ingest;
 mod order;
 mod serialization;
+mod text_ingest;
 mod utils;
 mod yaml_ingest;
 pub use order::types::{ArrayBias, ArraySamplerStrategy};
@@ -87,6 +88,32 @@ pub fn headson_many_yaml(
     Ok(out)
 }
 
+/// Same as `headson` but using the Text ingest path.
+pub fn headson_text(
+    input: Vec<u8>,
+    config: &RenderConfig,
+    priority_cfg: &PriorityConfig,
+    budget: usize,
+) -> Result<String> {
+    let arena = crate::ingest::parse_text_one(input, priority_cfg)?;
+    let order_build = order::build_order(&arena, priority_cfg)?;
+    let out = find_largest_render_under_budget(&order_build, config, budget);
+    Ok(out)
+}
+
+/// Same as `headson_many` but using the Text ingest path.
+pub fn headson_many_text(
+    inputs: Vec<(String, Vec<u8>)>,
+    config: &RenderConfig,
+    priority_cfg: &PriorityConfig,
+    budget: usize,
+) -> Result<String> {
+    let arena = crate::ingest::parse_text_many(inputs, priority_cfg)?;
+    let order_build = order::build_order(&arena, priority_cfg)?;
+    let out = find_largest_render_under_budget(&order_build, config, budget);
+    Ok(out)
+}
+
 fn find_largest_render_under_budget(
     order_build: &PriorityOrder,
     config: &RenderConfig,

{headson-0.6.2 → headson-0.6.3}/src/main.rs

@@ -29,7 +29,7 @@ struct Cli {
         long = "format",
         value_enum,
         default_value_t = OutputFormat::Auto,
-        help = "Output format: auto|json|yaml (filesets: auto is per-file)."
+        help = "Output format: auto|json|yaml|text (filesets: auto is per-file)."
     )]
     format: OutputFormat,
     #[arg(
@@ -110,7 +110,7 @@ struct Cli {
         long = "input-format",
         value_enum,
         default_value_t = InputFormat::Json,
-        help = "Input ingestion format: json or yaml."
+        help = "Input ingestion format: json|yaml|text."
     )]
     input_format: InputFormat,
 }
@@ -120,6 +120,7 @@ enum OutputFormat {
     Auto,
     Json,
     Yaml,
+    Text,
 }
 
 #[derive(Copy, Clone, Debug, ValueEnum)]
@@ -133,6 +134,7 @@ enum StyleArg {
 enum InputFormat {
     Json,
     Yaml,
+    Text,
 }
 
 fn main() -> Result<()> {
@@ -198,6 +200,9 @@ fn run_from_stdin(
         InputFormat::Yaml => {
             headson::headson_yaml(input_bytes, &cfg, &prio, eff)
         }
+        InputFormat::Text => {
+            headson::headson_text(input_bytes, &cfg, &prio, eff)
+        }
     }
 }
 
@@ -222,11 +227,22 @@ fn run_from_paths(
             lower.ends_with(".yaml") || lower.ends_with(".yml")
         })
     }
+    fn all_json_ext(entries: &InputEntries) -> bool {
+        entries.iter().all(|(name, _)| {
+            let lower = name.to_ascii_lowercase();
+            lower.ends_with(".json")
+        })
+    }
     if cli.inputs.len() > 1 {
-        let chosen_input = if matches!(cli.format, OutputFormat::Auto)
-            && any_yaml_ext(&entries)
-        {
-            InputFormat::Yaml
+        let chosen_input = if matches!(cli.format, OutputFormat::Auto) {
+            if any_yaml_ext(&entries) {
+                InputFormat::Yaml
+            } else if all_json_ext(&entries) {
+                InputFormat::Json
+            } else {
+                // Mixed or unknown extensions: treat as text to avoid JSON/YAML parse errors
+                InputFormat::Text
+            }
         } else {
             cli.input_format
         };
@@ -236,6 +252,7 @@ fn run_from_paths(
             OutputFormat::Auto => headson::OutputTemplate::Auto,
             OutputFormat::Json => map_json_template_for_style(cfg.style),
             OutputFormat::Yaml => headson::OutputTemplate::Yaml,
+            OutputFormat::Text => headson::OutputTemplate::Text,
         };
         let out = match chosen_input {
             InputFormat::Json => {
@@ -244,6 +261,9 @@ fn run_from_paths(
             InputFormat::Yaml => {
                 headson::headson_many_yaml(entries, &cfg, &prio, eff)?
             }
+            InputFormat::Text => {
+                headson::headson_many_text(entries, &cfg, &prio, eff)?
+            }
         };
         Ok((out, ignored))
     } else if included == 0 {
@@ -257,8 +277,10 @@ fn run_from_paths(
             OutputFormat::Auto => {
                 if is_yaml_ext {
                     InputFormat::Yaml
-                } else {
+                } else if lower.ends_with(".json") {
                     InputFormat::Json
+                } else {
+                    InputFormat::Text
                 }
             }
             _ => cli.input_format,
@@ -272,6 +294,9 @@ fn run_from_paths(
             InputFormat::Yaml => {
                 headson::headson_yaml(bytes, &cfg, &prio, eff)?
             }
+            InputFormat::Text => {
+                headson::headson_text(bytes, &cfg, &prio, eff)?
+            }
         };
         Ok((out, ignored))
     }
@@ -359,6 +384,7 @@ fn get_render_config_from(cli: &Cli) -> headson::RenderConfig {
             map_json_template_for_style(map_style(cli.style))
         }
         OutputFormat::Yaml => headson::OutputTemplate::Yaml,
+        OutputFormat::Text => headson::OutputTemplate::Text,
     };
     let space = if cli.compact || cli.no_space { "" } else { " " }.to_string();
     let newline = if cli.compact || cli.no_newline {
@@ -433,6 +459,7 @@ fn resolve_effective_template_for_stdin(
             map_json_template_for_style(style)
         }
         OutputFormat::Yaml => headson::OutputTemplate::Yaml,
+        OutputFormat::Text => headson::OutputTemplate::Text,
     }
 }
 
@@ -444,14 +471,15 @@ fn resolve_effective_template_for_single(
     match fmt {
         OutputFormat::Json => map_json_template_for_style(style),
         OutputFormat::Yaml => headson::OutputTemplate::Yaml,
+        OutputFormat::Text => headson::OutputTemplate::Text,
         OutputFormat::Auto => {
             if lower_name.ends_with(".yaml") || lower_name.ends_with(".yml") {
                 headson::OutputTemplate::Yaml
             } else if lower_name.ends_with(".json") {
                 map_json_template_for_style(style)
             } else {
-                // Unknown: pick based on style for JSON family.
-                map_json_template_for_style(style)
+                // Unknown extension: prefer text template.
+                headson::OutputTemplate::Text
             }
         }
     }

{headson-0.6.2 → headson-0.6.3}/src/serialization/fileset.rs

@@ -85,7 +85,7 @@ impl<'a> RenderScope<'a> {
             let fmt = Format::from_filename(raw_key);
             let template = match fmt {
                 Format::Yaml => OutputTemplate::Yaml,
-                Format::Json | Format::Unknown => match self.config.style {
+                Format::Json => match self.config.style {
                     crate::serialization::types::Style::Strict => {
                         OutputTemplate::Json
                     }
@@ -96,6 +96,7 @@ impl<'a> RenderScope<'a> {
                         OutputTemplate::Js
                     }
                 },
+                Format::Unknown => OutputTemplate::Text,
             };
             return self.render_node_to_string_with_template(
                 child_id, depth, false, template,