fix(tests): X1 GitError exception, X6 strict overlap, X16 leading-dot range

Author: nikolay-e

diffctx/python/_diffctx/__init__.py

@@ -1 +1,2 @@
 from ._diffctx import *  # noqa: F403
+from ._diffctx import GitError  # noqa: F401  # exception class is not picked up by `import *`

diffctx/src/git.rs

@@ -49,7 +49,15 @@ pub enum GitError {
 pub type Result<T> = std::result::Result<T, GitError>;
 
 fn validate_diff_range(diff_range: &str) -> Result<()> {
-    if !SAFE_RANGE_RE.is_match(diff_range.trim()) {
+    let trimmed = diff_range.trim();
+    // Reject leading-dot ranges like `..origin/main` (audit X16): the regex
+    // character class allows `.`, so a string of only dots/identifier-chars
+    // passes as a "ref" before being rejected by git itself with a less
+    // informative `fatal: ambiguous argument`. Surface the dedicated error.
+    if trimmed.starts_with('.') || trimmed.starts_with('/') {
+        return Err(GitError::InvalidRange(diff_range.to_string()));
+    }
+    if !SAFE_RANGE_RE.is_match(trimmed) {
         return Err(GitError::InvalidRange(diff_range.to_string()));
     }
     Ok(())

diffctx/src/interval.rs

@@ -44,7 +44,12 @@ impl IntervalIndex {
             if start == frag.start_line() && end == frag.end_line() {
                 continue;
             }
-            if end >= frag.start_line() {
+            // 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.
+            if end > frag.start_line() {
                 return true;
             }
         }

diffctx/src/pybridge.rs

@@ -1,16 +1,27 @@
 use std::path::Path;
 use std::sync::Arc;
 
+use pyo3::create_exception;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList};
 
 use crate::config::limits::{
     DEFAULT_PIPELINE_TIMEOUT_SECONDS, DEFAULT_PPR_ALPHA, DEFAULT_STOPPING_THRESHOLD,
 };
+use crate::git::GitError as RustGitError;
 use crate::mode::ScoringMode;
 use crate::pipeline;
 use crate::render::{DiffContextOutput, FragmentEntry};
 
+create_exception!(_diffctx, GitError, pyo3::exceptions::PyException);
+
+fn map_pipeline_err(e: anyhow::Error) -> PyErr {
+    if let Some(git_err) = e.downcast_ref::<RustGitError>() {
+        return GitError::new_err(git_err.to_string());
+    }
+    pyo3::exceptions::PyRuntimeError::new_err(e.to_string())
+}
+
 #[pyclass]
 #[derive(Clone)]
 pub struct PyFragment {
@@ -247,7 +258,7 @@ fn build_diff_context<'py>(
                 timeout,
             )
         })
-        .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(e.to_string()))?;
+        .map_err(map_pipeline_err)?;
     let total_ms = start.elapsed().as_secs_f64() * 1000.0;
 
     let dict = PyDict::new(py);
@@ -569,6 +580,7 @@ pub fn _diffctx(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<PyProjectGraph>()?;
     m.add_class::<PyQuotientGraph>()?;
     m.add_class::<PyModuleMetrics>()?;
+    m.add("GitError", m.py().get_type::<GitError>())?;
     Ok(())
 }
 

src/treemapper/diffctx/__init__.py

@@ -1,14 +1,7 @@
 from __future__ import annotations
 
-from .pipeline import build_diff_context
-
-
-class GitError(Exception):
-    """Raised when an underlying git operation fails.
-
-    Mirrors the Rust `_diffctx` error surface as a plain Python exception so
-    callers do not need to depend on PyO3-side classes.
-    """
+from _diffctx import GitError
 
+from .pipeline import build_diff_context
 
 __all__ = ["GitError", "build_diff_context"]