headson 0.5.4__tar.gz → 0.6.0__tar.gz

{headson-0.5.4 → headson-0.6.0}/Cargo.lock

@@ -266,7 +266,7 @@ dependencies = [
 
 [[package]]
 name = "headson"
-version = "0.5.4"
+version = "0.6.0"
 dependencies = [
  "anyhow",
  "assert_cmd",

{headson-0.5.4 → headson-0.6.0}/Cargo.toml

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

{headson-0.5.4 → headson-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: headson
-Version: 0.5.4
+Version: 0.6.0
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust

{headson-0.5.4 → headson-0.6.0}/pyproject.toml

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

{headson-0.5.4 → headson-0.6.0}/python/Cargo.lock

@@ -169,7 +169,7 @@ dependencies = [
 
 [[package]]
 name = "headson"
-version = "0.5.4"
+version = "0.6.0"
 dependencies = [
  "anyhow",
  "clap",
@@ -182,7 +182,7 @@ dependencies = [
 
 [[package]]
 name = "headson-python"
-version = "0.5.4"
+version = "0.6.0"
 dependencies = [
  "anyhow",
  "headson",

{headson-0.5.4 → headson-0.6.0}/python/Cargo.toml

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

{headson-0.5.4 → headson-0.6.0}/python/src/lib.rs

@@ -2,7 +2,7 @@ use anyhow::{bail, Result};
 use pyo3::exceptions::PyRuntimeError;
 use pyo3::prelude::*;
 use pyo3::types::PyModule;
-use headson_core::{ArraySamplerStrategy, OutputTemplate, PriorityConfig, RenderConfig};
+use headson_core::{ArraySamplerStrategy, ColorMode, OutputTemplate, PriorityConfig, RenderConfig};
 
 fn to_template(s: &str) -> Result<OutputTemplate> {
     match s.to_ascii_lowercase().as_str() {
@@ -22,7 +22,7 @@ fn render_config_with_sampler(
     let newline = "\n".to_string();
     let indent_unit = "  ".to_string();
     let prefer_tail_arrays = matches!(sampler, ArraySamplerStrategy::Tail);
-    Ok(RenderConfig { template: t, indent_unit, space, newline, prefer_tail_arrays })
+    Ok(RenderConfig { template: t, indent_unit, space, newline, prefer_tail_arrays, color_mode: ColorMode::Auto, color_enabled: false })
 }
 
 fn parse_skew(skew: &str) -> Result<ArraySamplerStrategy> {

{headson-0.5.4 → headson-0.6.0}/src/json_ingest/samplers/default.rs

@@ -21,7 +21,6 @@ struct SampleAccumulator<'a> {
     indices: &'a mut Vec<usize>,
 }
 
-#[inline]
 fn mix64(mut x: u64) -> u64 {
     x ^= x >> 30;
     x = x.wrapping_mul(0xbf58_476d_1ce4_e5b9);
@@ -30,7 +29,6 @@ fn mix64(mut x: u64) -> u64 {
     x ^ (x >> 31)
 }
 
-#[inline]
 fn accept_index(i: u64) -> bool {
     let h = mix64(i ^ RANDOM_ACCEPT_SEED);
     ((h >> 32) as u32) < RANDOM_ACCEPT_THRESHOLD

{headson-0.5.4 → headson-0.6.0}/src/lib.rs

@@ -25,7 +25,8 @@ pub use order::{
     NodeId, NodeKind, PriorityConfig, PriorityOrder, RankedNode, build_order,
 };
 
-pub use serialization::types::{OutputTemplate, RenderConfig};
+pub use serialization::color::resolve_color_enabled;
+pub use serialization::types::{ColorMode, OutputTemplate, RenderConfig};
 
 pub fn headson(
     input: Vec<u8>,
@@ -76,7 +77,11 @@ fn find_largest_render_under_budget(
     let mut inclusion_flags: Vec<u32> = vec![0; total];
     // Each render attempt bumps this non-zero identifier to create a fresh inclusion set.
     let mut render_set_id: u32 = 1;
-    let mut best_str: Option<String> = None;
+    // Measure length without color so ANSI escapes do not count toward the
+    // character budget. Then render once more with the requested color setting.
+    let mut best_k: Option<usize> = None;
+    let mut measure_cfg = config.clone();
+    measure_cfg.color_enabled = false;
 
     let _ = crate::utils::search::binary_search_max(lo, hi, |mid| {
         let s = crate::serialization::render_top_k(
@@ -84,19 +89,26 @@ fn find_largest_render_under_budget(
             mid,
             &mut inclusion_flags,
             render_set_id,
-            config,
+            &measure_cfg,
         );
         render_set_id = render_set_id.wrapping_add(1).max(1);
         if s.len() <= char_budget {
-            best_str = Some(s);
+            best_k = Some(mid);
             true
         } else {
             false
         }
     });
 
-    if let Some(s) = best_str {
-        s
+    if let Some(k) = best_k {
+        // Final render with original color settings
+        crate::serialization::render_top_k(
+            order_build,
+            k,
+            &mut inclusion_flags,
+            render_set_id,
+            config,
+        )
     } else {
         // Fallback: always render a single node (k=1) to produce the
         // shortest possible preview, even if it exceeds the byte budget.

{headson-0.5.4 → headson-0.6.0}/src/main.rs

@@ -1,9 +1,10 @@
 use std::fs::File;
+use std::io::IsTerminal as _;
 use std::io::{self, Read};
 use std::path::{Path, PathBuf};
 
 use anyhow::{Context, Result};
-use clap::{Parser, ValueEnum};
+use clap::{ArgAction, Parser, ValueEnum};
 use content_inspector::{ContentType, inspect};
 
 type InputEntry = (String, Vec<u8>);
@@ -65,6 +66,20 @@ struct Cli {
         help = "Prefer the beginning of arrays when truncating (keep first N)."
     )]
     head: bool,
+    #[arg(
+        long = "color",
+        action = ArgAction::SetTrue,
+        conflicts_with = "no_color",
+        help = "Force enable ANSI colors in output"
+    )]
+    color: bool,
+    #[arg(
+        long = "no-color",
+        action = ArgAction::SetTrue,
+        conflicts_with = "color",
+        help = "Disable ANSI colors in output"
+    )]
+    no_color: bool,
     #[arg(
         value_name = "INPUT",
         value_hint = clap::ValueHint::FilePath,
@@ -85,6 +100,9 @@ fn main() -> Result<()> {
     let cli = Cli::parse();
 
     let render_cfg = get_render_config_from(&cli);
+    // Resolve color auto-detection now (stdout is the surface for user output).
+    let _color_enabled =
+        render_cfg.color_mode.effective(io::stdout().is_terminal());
     let (output, ignore_notices) = if cli.inputs.is_empty() {
         (run_from_stdin(&cli, &render_cfg)?, Vec::new())
     } else {
@@ -222,11 +240,24 @@ fn ingest_paths(paths: &[PathBuf]) -> Result<(InputEntries, IgnoreNotices)> {
 }
 
 fn get_render_config_from(cli: &Cli) -> headson::RenderConfig {
-    let template = match cli.template {
-        Template::Json => headson::OutputTemplate::Json,
-        Template::Pseudo => headson::OutputTemplate::Pseudo,
-        Template::Js => headson::OutputTemplate::Js,
-    };
+    fn to_output_template(t: Template) -> headson::OutputTemplate {
+        match t {
+            Template::Json => headson::OutputTemplate::Json,
+            Template::Pseudo => headson::OutputTemplate::Pseudo,
+            Template::Js => headson::OutputTemplate::Js,
+        }
+    }
+    fn color_mode_from_flags(cli: &Cli) -> headson::ColorMode {
+        if cli.color {
+            headson::ColorMode::On
+        } else if cli.no_color {
+            headson::ColorMode::Off
+        } else {
+            headson::ColorMode::Auto
+        }
+    }
+
+    let template = to_output_template(cli.template);
     let space = if cli.compact || cli.no_space { "" } else { " " }.to_string();
     let newline = if cli.compact || cli.no_newline {
         ""
@@ -239,6 +270,8 @@ fn get_render_config_from(cli: &Cli) -> headson::RenderConfig {
     } else {
         cli.indent.clone()
     };
+    let color_mode = color_mode_from_flags(cli);
+    let color_enabled = headson::resolve_color_enabled(color_mode);
 
     headson::RenderConfig {
         template,
@@ -246,6 +279,8 @@ fn get_render_config_from(cli: &Cli) -> headson::RenderConfig {
         space,
         newline,
         prefer_tail_arrays: cli.tail,
+        color_mode,
+        color_enabled,
     }
 }
 

headson-0.6.0/src/serialization/color.rs

@@ -0,0 +1,113 @@
+use std::io::IsTerminal as _;
+
+use crate::serialization::types::ColorMode;
+
+// ANSI SGR fragments
+const RESET: &str = "\u{001b}[0m";
+const BOLD_BLUE: &str = "\u{001b}[1;34m";
+const GREEN: &str = "\u{001b}[32m";
+const CYAN: &str = "\u{001b}[36m";
+const BRIGHT_GRAY: &str = "\u{001b}[37m";
+const DARK_GRAY: &str = "\u{001b}[90m";
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum ColorRole {
+    Key,
+    String,
+    Number,
+    Bool,
+    Null,
+}
+
+pub fn wrap_role<S: Into<String>>(
+    s: S,
+    role: ColorRole,
+    enabled: bool,
+) -> String {
+    let s: String = s.into();
+    if !enabled {
+        return s;
+    }
+    let prefix = match role {
+        ColorRole::Key => BOLD_BLUE,
+        ColorRole::String => GREEN,
+        ColorRole::Number => CYAN,
+        ColorRole::Bool | ColorRole::Null => BRIGHT_GRAY,
+    };
+    let mut out = String::with_capacity(8 + 8 + s.len());
+    out.push_str(prefix);
+    out.push_str(&s);
+    out.push_str(RESET);
+    out
+}
+
+pub fn omission_marker(enabled: bool) -> &'static str {
+    if enabled {
+        "\u{001b}[90m…\u{001b}[0m"
+    } else {
+        "…"
+    }
+}
+
+pub fn color_comment<S: Into<String>>(body: S, enabled: bool) -> String {
+    if !enabled {
+        return body.into();
+    }
+    let b = body.into();
+    let mut out = String::with_capacity(b.len() + 8 + 4);
+    out.push_str(DARK_GRAY);
+    out.push_str(&b);
+    out.push_str(RESET);
+    out
+}
+
+fn env_bool(var: &str) -> Option<bool> {
+    std::env::var_os(var).map(|v| {
+        let s = v.to_string_lossy();
+        !(s == "0" || s.is_empty())
+    })
+}
+
+struct ColorEnv {
+    force: bool,            // CLICOLOR_FORCE=1
+    force_color: bool,      // FORCE_COLOR=1
+    no_color: bool,         // NO_COLOR present
+    dumb: bool,             // TERM=dumb
+    clicolor: Option<bool>, // CLICOLOR=0/1
+    is_tty: bool,
+}
+
+fn read_color_env() -> ColorEnv {
+    let term_dumb = std::env::var_os("TERM")
+        .map(|t| t.to_string_lossy() == "dumb")
+        .unwrap_or(false);
+    ColorEnv {
+        force: matches!(env_bool("CLICOLOR_FORCE"), Some(true)),
+        force_color: matches!(env_bool("FORCE_COLOR"), Some(true)),
+        no_color: std::env::var_os("NO_COLOR").is_some(),
+        dumb: term_dumb,
+        clicolor: env_bool("CLICOLOR"),
+        is_tty: std::io::stdout().is_terminal(),
+    }
+}
+
+fn auto_color_enabled(env: &ColorEnv) -> bool {
+    if env.force || env.force_color {
+        return true;
+    }
+    if env.no_color || env.dumb {
+        return false;
+    }
+    if let Some(b) = env.clicolor {
+        return b && env.is_tty;
+    }
+    env.is_tty
+}
+
+pub fn resolve_color_enabled(mode: ColorMode) -> bool {
+    match mode {
+        ColorMode::On => true,
+        ColorMode::Off => false,
+        ColorMode::Auto => auto_color_enabled(&read_color_env()),
+    }
+}

{headson-0.5.4 → headson-0.6.0}/src/serialization/fileset.rs

@@ -17,7 +17,7 @@ impl<'a> RenderScope<'a> {
         out.push_str("// ");
         out.push_str(raw_key);
         out.push_str(nl);
-        let rendered = self.serialize_node(child_pq_id, depth, false);
+        let rendered = self.render_node_to_string(child_pq_id, depth, false);
         out.push_str(&rendered);
         out.push(';');
         out.push_str(nl);
@@ -58,7 +58,7 @@ impl<'a> RenderScope<'a> {
         out.push_str(raw_key);
         out.push_str(" <==");
         out.push_str(nl);
-        let rendered = self.serialize_node(child_pq_id, depth, false);
+        let rendered = self.render_node_to_string(child_pq_id, depth, false);
         out.push_str(&rendered);
     }