diffctx 1.8.1__tar.gz → 1.9.1__tar.gz

{diffctx-1.8.1 → diffctx-1.9.1}/CHANGELOG.md

@@ -7,6 +7,35 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.9.0] - 2026-06-14
+
+### Added
+
+- Diff-context output now leads with an orientation header — `commit_message`
+  and `changed_files` — in every format (YAML/JSON/Markdown/text), so a reader
+  sees *what* changed before reading any fragment.
+- Each fragment carries a `role` of `changed` when it overlaps the diff hunks
+  (omitted for supporting context). Changed code is emitted first; context
+  follows, ordered by descending per-file relevance instead of alphabetically.
+
+### Changed
+
+- Line-contiguous fragments of the same role within a file are merged into a
+  single entry, cutting the per-fragment scaffolding that dominated output made
+  up of one-line snippets (lossless on line coverage).
+
+### Fixed
+
+- `get_changed_files` and `get_untracked_files` canonicalize paths consistently
+  with deleted/discovered files, preventing duplicate fragments when a tracked
+  path traverses a symlinked directory.
+- Signature extraction no longer terminates at braces inside parameter defaults
+  or annotations (e.g. Python `def f(x={}):`), which previously truncated the
+  signature mid-parameter-list.
+- The post-pass that rescues unrepresented changed files reuses the open
+  `git cat-file --batch` reader instead of spawning a `git show` per file.
+- Degraded token-count fallback returns 0 for the empty string (was 1).
+
 ## [1.8.0]
 
 ### Added

{diffctx-1.8.1 → diffctx-1.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffctx
-Version: 1.8.1
+Version: 1.9.1
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{diffctx-1.8.1 → diffctx-1.9.1}/diffctx/src/filtering.rs

@@ -143,9 +143,8 @@ fn find_hub_noise_paths(graph: &Graph, changed_paths: &FxHashSet<Arc<str>>) -> F
 
     noise_counts
         .into_iter()
-        .filter(|(p, count)| {
-            *count >= 1
-                && !direct_edge_paths.contains(p)
+        .filter(|(p, _count)| {
+            !direct_edge_paths.contains(p)
                 && !changed_dirs.contains(
                     &Path::new(p.as_ref())
                         .parent()

{diffctx-1.8.1 → diffctx-1.9.1}/diffctx/src/git.rs

@@ -376,7 +376,15 @@ pub fn get_changed_files(repo_root: &Path, diff_range: Option<&str>) -> Result<V
         args.push(range);
     }
     let parts = run_git_z(repo_root, &args)?;
-    Ok(parts.iter().map(|p| repo_root.join(p)).collect())
+    Ok(parts
+        .iter()
+        .map(|p| {
+            repo_root
+                .join(p)
+                .canonicalize()
+                .unwrap_or_else(|_| repo_root.join(p))
+        })
+        .collect())
 }
 
 pub fn get_deleted_files(repo_root: &Path, diff_range: Option<&str>) -> Result<FxHashSet<PathBuf>> {
@@ -481,7 +489,15 @@ pub fn get_untracked_files(repo_root: &Path) -> Result<Vec<PathBuf>> {
         repo_root,
         &["ls-files", "--others", "--exclude-standard", "-z"],
     )?;
-    Ok(parts.iter().map(|p| repo_root.join(p)).collect())
+    Ok(parts
+        .iter()
+        .map(|p| {
+            repo_root
+                .join(p)
+                .canonicalize()
+                .unwrap_or_else(|_| repo_root.join(p))
+        })
+        .collect())
 }
 
 pub struct CatFileBatch {

{diffctx-1.8.1 → diffctx-1.9.1}/diffctx/src/interval.rs

@@ -45,10 +45,12 @@ impl IntervalIndex {
                 continue;
             }
             // Strict `>`: a fragment starting on the very last line of an
-            // already-selected fragment is adjacent, not overlapping. Compact
-            // languages (Rust/Go/Scala one-liners, Lisp `}{` chains) routinely
-            // produce back-to-back fragments sharing exactly that boundary
-            // line; treating it as overlap silently drops the next fragment.
+            // already-selected fragment shares exactly one boundary line. We
+            // deliberately tolerate that one-line overlap rather than drop the
+            // candidate, because compact languages (Rust/Go/Scala one-liners,
+            // Lisp `}{` chains) routinely produce back-to-back fragments sharing
+            // that boundary line; rejecting them would silently discard the
+            // next fragment's unique content for the sake of one duplicated line.
             if end > frag.start_line() {
                 return true;
             }

{diffctx-1.8.1 → diffctx-1.9.1}/diffctx/src/memory_pipeline.rs

@@ -165,7 +165,20 @@ pub fn build_diff_context_in_memory(
     );
 
     let dummy_root = Path::new(".");
-    build_diff_context_output(dummy_root, &selected, no_content)
+    let mut changed_list: Vec<String> = changed_paths.iter().cloned().collect();
+    changed_list.sort();
+    let change = crate::render::ChangeSummary {
+        commit_message: None,
+        changed_files: changed_list,
+    };
+    build_diff_context_output(
+        dummy_root,
+        &selected,
+        no_content,
+        &core_ids,
+        &scoring_result.rel_scores,
+        change,
+    )
 }
 
 fn compute_memory_hunks(
@@ -323,6 +336,8 @@ fn empty_output(name: &str) -> DiffContextOutput {
     DiffContextOutput {
         name: name.to_string(),
         output_type: "diff_context".to_string(),
+        commit_message: None,
+        changed_files: Vec::new(),
         fragment_count: 0,
         fragments: Vec::new(),
         latency: None,

{diffctx-1.8.1 → diffctx-1.9.1}/diffctx/src/pipeline.rs

@@ -42,6 +42,7 @@ pub struct ScoredState {
     pub needs: Vec<InformationNeed>,
     pub changed_files: Vec<PathBuf>,
     pub preferred_revs: Vec<String>,
+    pub commit_message: Option<String>,
     pub heavy_latency_ms: HeavyLatencyMs,
 }
 
@@ -157,6 +158,15 @@ pub fn compute_scored_state(
         .map(git::split_diff_range)
         .unwrap_or((None, None));
     let preferred_revs = build_preferred_revs(base_rev.as_deref(), head_rev.as_deref());
+    let commit_message = head_rev
+        .as_deref()
+        .and_then(|h| git::get_commit_message(&root_dir, h).ok())
+        .and_then(|m| {
+            m.lines()
+                .map(str::trim)
+                .find(|l| !l.is_empty())
+                .map(str::to_string)
+        });
 
     let t0 = Instant::now();
 
@@ -303,6 +313,7 @@ pub fn compute_scored_state(
         needs,
         changed_files,
         preferred_revs,
+        commit_message,
         heavy_latency_ms,
     })
 }
@@ -412,7 +423,27 @@ pub fn select_with_params(
         + select_ms;
 
     let cap_stats = state.scoring_result.graph.cap_stats;
-    let mut output = render::build_diff_context_output(&state.root_dir, &selected, no_content);
+    let change = render::ChangeSummary {
+        commit_message: state.commit_message.clone(),
+        changed_files: state
+            .changed_files
+            .iter()
+            .map(|p| {
+                p.strip_prefix(&state.root_dir)
+                    .unwrap_or(p)
+                    .to_string_lossy()
+                    .replace('\\', "/")
+            })
+            .collect(),
+    };
+    let mut output = render::build_diff_context_output(
+        &state.root_dir,
+        &selected,
+        no_content,
+        &state.core_ids,
+        &state.scoring_result.rel_scores,
+        change,
+    );
     output.latency = Some(render::LatencyBreakdown {
         parse_changed_ms: state.heavy_latency_ms.parse_changed,
         universe_walk_ms: state.heavy_latency_ms.universe_walk,
@@ -479,10 +510,37 @@ fn build_diff_context_full(
     assign_token_counts(&mut sig_frags);
     all_fragments.extend(sig_frags);
     changed_files.sort();
+    let core_ids = identify_core_fragments(&hunks, &all_fragments);
     let selected = select_full_mode(&all_fragments, &changed_files);
     batch_reader.close();
+    let commit_message = head_rev
+        .as_deref()
+        .and_then(|h| git::get_commit_message(&root_dir, h).ok())
+        .and_then(|m| {
+            m.lines()
+                .map(str::trim)
+                .find(|l| !l.is_empty())
+                .map(str::to_string)
+        });
+    let change = render::ChangeSummary {
+        commit_message,
+        changed_files: changed_files
+            .iter()
+            .map(|p| {
+                p.strip_prefix(&root_dir)
+                    .unwrap_or(p)
+                    .to_string_lossy()
+                    .replace('\\', "/")
+            })
+            .collect(),
+    };
     Ok(render::build_diff_context_output(
-        &root_dir, &selected, no_content,
+        &root_dir,
+        &selected,
+        no_content,
+        &core_ids,
+        &FxHashMap::default(),
+        change,
     ))
 }
 
@@ -504,6 +562,7 @@ fn empty_scored_state(root_dir: PathBuf) -> ScoredState {
         needs: Vec::new(),
         changed_files: Vec::new(),
         preferred_revs: Vec::new(),
+        commit_message: None,
         heavy_latency_ms: HeavyLatencyMs::default(),
     }
 }
@@ -519,6 +578,8 @@ fn empty_output(root_dir: &Path) -> DiffContextOutput {
     DiffContextOutput {
         name,
         output_type: "diff_context".to_string(),
+        commit_message: None,
+        changed_files: Vec::new(),
         fragment_count: 0,
         fragments: Vec::new(),
         latency: None,

{diffctx-1.8.1 → diffctx-1.9.1}/diffctx/src/postpass.rs

@@ -207,7 +207,7 @@ pub fn ensure_changed_files_represented(
     remaining_budget: u32,
     root_dir: &Path,
     preferred_revs: &[String],
-    _batch_reader: Option<&mut CatFileBatch>,
+    mut batch_reader: Option<&mut CatFileBatch>,
 ) {
     let selected_paths: FxHashSet<String> = selected
         .iter()
@@ -245,7 +245,12 @@ pub fn ensure_changed_files_represented(
         let path_str = path.to_string_lossy().to_string();
         let candidates = frags_by_path.get(&path_str).cloned().unwrap_or_default();
         let candidates = if candidates.is_empty() {
-            match create_whole_file_fragment(path, root_dir, preferred_revs, None) {
+            match create_whole_file_fragment(
+                path,
+                root_dir,
+                preferred_revs,
+                batch_reader.as_deref_mut(),
+            ) {
                 Some(f) => vec![f],
                 None => continue,
             }

{diffctx-1.8.1 → diffctx-1.9.1}/diffctx/src/pybridge.rs

@@ -156,6 +156,8 @@ impl DiffContextResult {
         DiffContextOutput {
             name: self.name.clone(),
             output_type: "diff_context".to_string(),
+            commit_message: None,
+            changed_files: Vec::new(),
             fragment_count: self.fragment_count,
             fragments: self
                 .fragments
@@ -163,6 +165,7 @@ impl DiffContextResult {
                 .map(|f| FragmentEntry {
                     path: f.path.clone(),
                     lines: f.lines.clone(),
+                    role: None,
                     kind: f.kind.clone(),
                     symbol: f.symbol.clone(),
                     content: f.content.clone(),
@@ -277,6 +280,12 @@ fn build_diff_context<'py>(
     let dict = PyDict::new(py);
     dict.set_item("name", &output.name)?;
     dict.set_item("type", "diff_context")?;
+    if let Some(ref msg) = output.commit_message {
+        dict.set_item("commit_message", msg)?;
+    }
+    if !output.changed_files.is_empty() {
+        dict.set_item("changed_files", &output.changed_files)?;
+    }
     dict.set_item("fragment_count", output.fragment_count)?;
 
     let frag_list = PyList::empty(py);
@@ -284,6 +293,9 @@ fn build_diff_context<'py>(
         let frag_dict = PyDict::new(py);
         frag_dict.set_item("path", &entry.path)?;
         frag_dict.set_item("lines", &entry.lines)?;
+        if let Some(ref role) = entry.role {
+            frag_dict.set_item("role", role)?;
+        }
         frag_dict.set_item("kind", &entry.kind)?;
         if let Some(ref s) = entry.symbol {
             frag_dict.set_item("symbol", s)?;
@@ -381,6 +393,8 @@ fn select_with_params<'py>(
                     .map(|n| n.to_string_lossy().to_string())
                     .unwrap_or_else(|| inner.root_dir.to_string_lossy().to_string()),
                 output_type: "diff_context".to_string(),
+                commit_message: None,
+                changed_files: Vec::new(),
                 fragment_count: 0,
                 fragments: Vec::new(),
                 latency: None,
@@ -398,6 +412,12 @@ fn diff_context_output_to_dict<'py>(
     let dict = PyDict::new(py);
     dict.set_item("name", &output.name)?;
     dict.set_item("type", "diff_context")?;
+    if let Some(ref msg) = output.commit_message {
+        dict.set_item("commit_message", msg)?;
+    }
+    if !output.changed_files.is_empty() {
+        dict.set_item("changed_files", &output.changed_files)?;
+    }
     dict.set_item("fragment_count", output.fragment_count)?;
 
     let frag_list = PyList::empty(py);
@@ -405,6 +425,9 @@ fn diff_context_output_to_dict<'py>(
         let frag_dict = PyDict::new(py);
         frag_dict.set_item("path", &entry.path)?;
         frag_dict.set_item("lines", &entry.lines)?;
+        if let Some(ref role) = entry.role {
+            frag_dict.set_item("role", role)?;
+        }
         frag_dict.set_item("kind", &entry.kind)?;
         if let Some(ref s) = entry.symbol {
             frag_dict.set_item("symbol", s)?;

{diffctx-1.8.1 → diffctx-1.9.1}/diffctx/src/render.rs

@@ -1,19 +1,32 @@
-use std::collections::BTreeMap;
 use std::path::Path;
 use std::sync::Arc;
 
 use once_cell::sync::Lazy;
 use regex::Regex;
+use rustc_hash::{FxHashMap, FxHashSet};
 use serde::Serialize;
 
 use crate::config::render::RENDER;
-use crate::types::{Fragment, FragmentKind};
+use crate::types::{Fragment, FragmentId, FragmentKind};
+
+/// Orientation header for the diff-context output: tells the reader *what*
+/// changed before they read the fragments. Empty for working-tree / no-commit
+/// diffs.
+#[derive(Default)]
+pub struct ChangeSummary {
+    pub commit_message: Option<String>,
+    pub changed_files: Vec<String>,
+}
 
 #[derive(Serialize)]
 pub struct DiffContextOutput {
     pub name: String,
     #[serde(rename = "type")]
     pub output_type: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub commit_message: Option<String>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub changed_files: Vec<String>,
     pub fragment_count: usize,
     pub fragments: Vec<FragmentEntry>,
     #[serde(skip)]
@@ -71,6 +84,11 @@ pub struct LatencyBreakdown {
 pub struct FragmentEntry {
     pub path: String,
     pub lines: String,
+    /// `Some("changed")` for fragments overlapping the diff hunks; omitted
+    /// (treated as supporting context) otherwise. This is the single signal a
+    /// reader needs to tell the change apart from its context.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub role: Option<String>,
     pub kind: String,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub symbol: Option<String>,
@@ -189,36 +207,111 @@ fn create_fragment_entry(frag: &Fragment, path_str: &str) -> FragmentEntry {
     FragmentEntry {
         path: path_str.to_string(),
         lines: format!("{}-{}", frag.start_line(), frag.end_line()),
+        role: None,
         kind: frag.kind.as_str().to_string(),
         symbol,
         content,
     }
 }
 
+/// Collapse a file's fragments (sorted by start line) into the rendered
+/// entries, merging runs of same-role, line-contiguous fragments
+/// (`next.start == cur.end + 1`) into one. Merging touching ranges is lossless
+/// on line coverage and removes the per-fragment scaffolding tax that dominates
+/// output dominated by one-line snippets.
+fn merge_file_fragments(
+    rel_path: &str,
+    frags: &[&Fragment],
+    core_ids: &FxHashSet<FragmentId>,
+) -> Vec<(bool, u32, FragmentEntry)> {
+    let mut out: Vec<(bool, u32, FragmentEntry)> = Vec::new();
+    let mut i = 0;
+    while i < frags.len() {
+        let first = frags[i];
+        let role_changed = core_ids.contains(&first.id);
+        let mut end = first.end_line();
+        let mut parts: Vec<&str> = vec![first.content.trim_end_matches('\n')];
+        let mut j = i + 1;
+        while j < frags.len() {
+            let next = frags[j];
+            if core_ids.contains(&next.id) == role_changed && next.start_line() == end + 1 {
+                parts.push(next.content.trim_end_matches('\n'));
+                end = next.end_line();
+                j += 1;
+            } else {
+                break;
+            }
+        }
+
+        let mut entry = create_fragment_entry(first, rel_path);
+        if j > i + 1 {
+            entry.lines = format!("{}-{}", first.start_line(), end);
+            let merged = parts.join("\n");
+            entry.content = if merged.is_empty() {
+                None
+            } else {
+                Some(Arc::from(merged.as_str()))
+            };
+        }
+        entry.role = role_changed.then(|| "changed".to_string());
+        out.push((role_changed, first.start_line(), entry));
+        i = j;
+    }
+    out
+}
+
 pub fn build_diff_context_output(
     repo_root: &Path,
     selected: &[Fragment],
     no_content: bool,
+    core_ids: &FxHashSet<FragmentId>,
+    rel_scores: &FxHashMap<FragmentId, f64>,
+    change: ChangeSummary,
 ) -> DiffContextOutput {
-    let mut by_path: BTreeMap<String, Vec<&Fragment>> = BTreeMap::new();
+    let mut by_path: FxHashMap<String, Vec<&Fragment>> = FxHashMap::default();
     for frag in selected {
-        let rel_path = get_relative_path(frag, repo_root);
-        by_path.entry(rel_path).or_default().push(frag);
+        by_path
+            .entry(get_relative_path(frag, repo_root))
+            .or_default()
+            .push(frag);
     }
 
-    let mut fragments_out: Vec<FragmentEntry> = Vec::new();
+    // Changed code first (the answer to "what changed"), then supporting
+    // context ordered by descending per-file relevance so the reader's primacy
+    // attention lands on the most relevant material, not on alphabetical noise.
+    let mut changed: Vec<(String, u32, FragmentEntry)> = Vec::new();
+    let mut context: Vec<(f64, String, u32, FragmentEntry)> = Vec::new();
     for (rel_path, frags) in &by_path {
-        let mut sorted_frags: Vec<&&Fragment> = frags.iter().collect();
-        sorted_frags.sort_by_key(|f| f.start_line());
-        for frag in sorted_frags {
-            let mut entry = create_fragment_entry(frag, rel_path);
+        let mut sorted: Vec<&Fragment> = frags.clone();
+        sorted.sort_by_key(|f| f.start_line());
+        let file_rel = sorted
+            .iter()
+            .map(|f| rel_scores.get(&f.id).copied().unwrap_or(0.0))
+            .fold(0.0_f64, f64::max);
+        for (role_changed, start, mut entry) in merge_file_fragments(rel_path, &sorted, core_ids) {
             if no_content {
                 entry.content = None;
             }
-            fragments_out.push(entry);
+            if role_changed {
+                changed.push((rel_path.clone(), start, entry));
+            } else {
+                context.push((file_rel, rel_path.clone(), start, entry));
+            }
         }
     }
 
+    changed.sort_by(|a, b| a.0.cmp(&b.0).then(a.1.cmp(&b.1)));
+    context.sort_by(|a, b| {
+        b.0.partial_cmp(&a.0)
+            .unwrap_or(std::cmp::Ordering::Equal)
+            .then(a.1.cmp(&b.1))
+            .then(a.2.cmp(&b.2))
+    });
+
+    let mut fragments_out: Vec<FragmentEntry> = Vec::with_capacity(changed.len() + context.len());
+    fragments_out.extend(changed.into_iter().map(|(_, _, e)| e));
+    fragments_out.extend(context.into_iter().map(|(_, _, _, e)| e));
+
     let resolved = repo_root
         .canonicalize()
         .unwrap_or_else(|_| repo_root.to_path_buf());
@@ -230,6 +323,8 @@ pub fn build_diff_context_output(
     DiffContextOutput {
         name,
         output_type: "diff_context".to_string(),
+        commit_message: change.commit_message,
+        changed_files: change.changed_files,
         fragment_count: fragments_out.len(),
         fragments: fragments_out,
         latency: None,

{diffctx-1.8.1 → diffctx-1.9.1}/diffctx/src/signatures.rs

@@ -72,7 +72,11 @@ fn find_signature_end(lines: &[&str]) -> usize {
         if op > 0 {
             seen_open_paren = true;
         }
-        if ob - cb > 0 {
+        // A body-opening brace only ends the signature once we are outside the
+        // parameter list. Braces inside parameter defaults or annotations
+        // (e.g. Python `def f(x={}):`) appear while `paren_depth > 0` and must
+        // not truncate the signature mid-parameter-list.
+        if paren_depth <= 0 && ob - cb > 0 {
             return i + 1;
         }
         if seen_open_paren && paren_depth <= 0 {

{diffctx-1.8.1 → diffctx-1.9.1}/diffctx/src/tokenizer.rs

@@ -40,6 +40,7 @@ pub fn count_tokens(text: &str) -> u32 {
     // aborting the host process.
     match try_count_tokens(text) {
         Ok(n) => n,
+        Err(_) if text.is_empty() => 0,
         Err(_) => ((text.len() as u32) / 4).max(1),
     }
 }

{diffctx-1.8.1 → diffctx-1.9.1}/pyproject.toml

@@ -5,7 +5,7 @@ requires = [ "maturin>=1.10,<1.14" ]
 
 [project]
 name = "diffctx"
-version = "1.8.1"
+version = "1.9.1"
 description = "Export codebase structure and contents for AI/LLM context"
 readme = "README.md"
 keywords = [

diffctx-1.9.1/src/diffctx/version.py

@@ -0,0 +1 @@
+__version__ = "1.9.1"

{diffctx-1.8.1 → diffctx-1.9.1}/src/diffctx/writer.py

@@ -98,6 +98,8 @@ def _write_yaml_node(file: TextIO, node: dict[str, Any], indent: str = "") -> No
 def _write_yaml_fragment(file: TextIO, frag: dict[str, Any], indent: str = "") -> None:
     file.write(f'{indent}- path: "{_escape_yaml_string(frag.get("path", ""))}"\n')
     file.write(f'{indent}  lines: "{_escape_yaml_string(frag.get("lines", ""))}"\n')
+    if frag.get("role"):
+        file.write(f'{indent}  role: "{_escape_yaml_string(frag["role"])}"\n')
     file.write(f'{indent}  kind: "{_escape_yaml_string(frag.get("kind", "unknown"))}"\n')
 
     if frag.get("symbol"):
@@ -113,6 +115,12 @@ def write_tree_yaml(file: TextIO, tree: dict[str, Any]) -> None:
     file.write(f"type: {tree['type']}\n")
 
     if tree.get("type") == "diff_context" and tree.get("fragments"):
+        if tree.get("commit_message"):
+            file.write(f'commit_message: "{_escape_yaml_string(str(tree["commit_message"]))}"\n')
+        if tree.get("changed_files"):
+            file.write("changed_files:\n")
+            for path in tree["changed_files"]:
+                file.write(f'  - "{_escape_yaml_string(str(path))}"\n')
         file.write(f"fragment_count: {len(tree['fragments'])}\n")
         file.write("fragments:\n")
         for frag in tree["fragments"]:
@@ -171,6 +179,8 @@ def _write_text_fragment(file: TextIO, frag: dict[str, Any], indent: str = "") -
         header += f" ({symbol})"
     if kind:
         header += f" [{kind}]"
+    if frag.get("role"):
+        header += f" <{frag['role']}>"
     file.write(f"{indent}{header}\n")
 
     if frag.get("content"):
@@ -192,6 +202,10 @@ def write_tree_text(file: TextIO, tree: dict[str, Any]) -> None:
         file.write(f"{name}/\n")
 
     if tree_type == "diff_context" and tree.get("fragments"):
+        if tree.get("commit_message"):
+            file.write(f"  change: {tree['commit_message']}\n")
+        if tree.get("changed_files"):
+            file.write(f"  changed files: {', '.join(str(p) for p in tree['changed_files'])}\n")
         for frag in tree["fragments"]:
             _write_text_fragment(file, frag, "  ")
     elif tree.get("children"):
@@ -301,6 +315,8 @@ def _write_markdown_fragment(file: TextIO, frag: dict[str, Any]) -> None:
         header += f" **{_escape_markdown(symbol)}**"
     if kind:
         header += f" _{_escape_markdown(kind)}_"
+    if frag.get("role") == "changed":
+        header = f"🔹 {header} — **changed**"
     file.write(f"## {header}\n\n")
 
     if frag.get("content"):
@@ -319,6 +335,13 @@ def write_tree_markdown(file: TextIO, tree: dict[str, Any]) -> None:
         file.write(f"# {name}/\n\n")
 
     if tree_type == "diff_context" and tree.get("fragments"):
+        if tree.get("commit_message"):
+            file.write(f"> {tree['commit_message']}\n\n")
+        if tree.get("changed_files"):
+            file.write("**Changed files:**\n\n")
+            for path in tree["changed_files"]:
+                file.write(f"- {_escape_md_inline_code(str(path))}\n")
+            file.write("\n")
         for frag in tree["fragments"]:
             _write_markdown_fragment(file, frag)
     elif tree.get("children"):

diffctx-1.8.1/src/diffctx/version.py

@@ -1 +0,0 @@
-__version__ = "1.8.1"