diffctx 1.10.1__tar.gz → 1.10.2__tar.gz

{diffctx-1.10.1 → diffctx-1.10.2}/PKG-INFO

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

{diffctx-1.10.1 → diffctx-1.10.2}/diffctx/src/git.rs

@@ -500,6 +500,135 @@ pub fn get_untracked_files(repo_root: &Path) -> Result<Vec<PathBuf>> {
         .collect())
 }
 
+/// Rewrites one `.diffctx/ignore` pattern line to be anchored to the
+/// directory that contains the `.diffctx/` folder (`rel`, repo-root-relative,
+/// "" for the repo root itself). Mirrors `_process_ignore_line` in the
+/// Python tree-mode ignore resolver (`src/diffctx/ignore.py`) so a pattern
+/// declared in `sub/.diffctx/ignore` only ever matches within `sub/`.
+fn anchor_diffctx_ignore_line(line: &str, rel: &str) -> String {
+    let (neg, pat) = match line.strip_prefix('!') {
+        Some(rest) => (true, rest),
+        None => (false, line),
+    };
+    let pat_no_trailing_slash = pat.trim_end_matches('/');
+    let full = if pat_no_trailing_slash.starts_with('/') || pat_no_trailing_slash.contains('/') {
+        let anchored = pat.trim_start_matches('/');
+        if rel.is_empty() {
+            format!("/{anchored}")
+        } else {
+            format!("/{rel}/{anchored}")
+        }
+    } else if rel.is_empty() {
+        pat.to_string()
+    } else {
+        format!("{rel}/**/{pat}")
+    };
+    if neg { format!("!{full}") } else { full }
+}
+
+/// Finds every `.diffctx/ignore` file tracked or present in `repo_root`
+/// (any depth) and returns its patterns rewritten to be repo-root-relative,
+/// ready to feed into a combined gitignore-syntax exclude file.
+fn collect_diffctx_ignore_patterns(repo_root: &Path) -> Vec<String> {
+    let Ok(files) = run_git_z(
+        repo_root,
+        &[
+            "ls-files",
+            "-z",
+            "--cached",
+            "--others",
+            "--exclude-standard",
+            "--",
+            ":(glob)**/.diffctx/ignore",
+        ],
+    ) else {
+        return Vec::new();
+    };
+
+    let mut patterns = Vec::new();
+    for raw in &files {
+        let rel_path = unquote_c_style(raw);
+        if !rel_path.ends_with(".diffctx/ignore") {
+            continue;
+        }
+        let rel_dir = rel_path
+            .strip_suffix(".diffctx/ignore")
+            .unwrap_or("")
+            .trim_end_matches('/');
+        let Ok(content) = std::fs::read_to_string(repo_root.join(&rel_path)) else {
+            continue;
+        };
+        for line in content.lines() {
+            let line = line.trim_end();
+            if line.is_empty() || line.starts_with('#') {
+                continue;
+            }
+            patterns.push(anchor_diffctx_ignore_line(line, rel_dir));
+        }
+    }
+    patterns
+}
+
+/// Returns the subset of `rel_paths` (repo-root-relative) excluded by either
+/// `.gitignore` (via git's own engine, so nesting/negation/`**` are handled
+/// correctly) or `.diffctx/ignore` (patterns anchored per-directory and fed
+/// to git as a temporary `core.excludesFile`, so the same engine evaluates
+/// both mechanisms uniformly). Best-effort: any failure returns an empty set
+/// rather than blocking the diff pipeline on an ignore-resolution problem.
+pub fn find_ignored_paths(repo_root: &Path, rel_paths: &[String]) -> FxHashSet<String> {
+    if rel_paths.is_empty() {
+        return FxHashSet::default();
+    }
+
+    let diffctx_patterns = collect_diffctx_ignore_patterns(repo_root);
+    let temp_excludes = if diffctx_patterns.is_empty() {
+        None
+    } else {
+        let path = std::env::temp_dir().join(format!("diffctx-ignore-{}.tmp", std::process::id()));
+        match std::fs::write(&path, diffctx_patterns.join("\n")) {
+            Ok(()) => Some(path),
+            Err(_) => None,
+        }
+    };
+
+    let mut args: Vec<String> = vec!["check-ignore".into(), "--no-index".into()];
+    if let Some(ref path) = temp_excludes {
+        args.insert(0, format!("core.excludesFile={}", path.display()));
+        args.insert(0, "-c".into());
+    }
+    args.push("--".into());
+    args.extend(rel_paths.iter().cloned());
+    let arg_refs: Vec<&str> = args.iter().map(String::as_str).collect();
+
+    let result = (|| -> Result<FxHashSet<String>> {
+        let mut cmd = Command::new("git");
+        cmd.arg("-C")
+            .arg(repo_root)
+            .args(&arg_refs)
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped());
+        let child = cmd.spawn()?;
+        let output = wait_with_timeout(child, Duration::from_secs(git_timeout()), &arg_refs)?;
+        // Exit code 1 from `check-ignore` means "none of the given paths are
+        // ignored" — not a failure. Any other non-zero code is a real error.
+        if !output.status.success() && output.status.code() != Some(1) {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            return Err(GitError::CommandFailed(format!(
+                "git check-ignore failed: {}",
+                stderr.trim()
+            )));
+        }
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        Ok(stdout.lines().map(unquote_c_style).collect())
+    })();
+
+    if let Some(path) = temp_excludes {
+        let _ = std::fs::remove_file(path);
+    }
+
+    result.unwrap_or_default()
+}
+
 pub struct CatFileBatch {
     repo_root: PathBuf,
     child: Option<Child>,

{diffctx-1.10.1 → diffctx-1.10.2}/diffctx/src/parsers/markdown.rs

@@ -54,8 +54,8 @@ impl FragmentationStrategy for MarkdownStrategy {
         let total_lines = lines.len() as u32;
         let mut fragments: Vec<Fragment> = Vec::new();
 
-        for (idx, &(start_line, level, _)) in headings.iter().enumerate() {
-            let end_line = find_section_end(&headings, idx, level, total_lines);
+        for (idx, &(start_line, _level, _)) in headings.iter().enumerate() {
+            let end_line = find_section_end(&headings, idx, total_lines);
             if end_line < start_line {
                 continue;
             }
@@ -90,16 +90,57 @@ impl FragmentationStrategy for MarkdownStrategy {
     }
 }
 
-fn find_section_end(
-    headings: &[(u32, u32, String)],
-    idx: usize,
-    level: u32,
-    total_lines: u32,
-) -> u32 {
-    for &(next_line, next_level, _) in &headings[idx + 1..] {
-        if next_level <= level {
-            return next_line - 1;
-        }
+/// A heading's own fragment ends at the very next heading, regardless of
+/// level — not at the next heading of the *same or higher* level. The old
+/// same-or-higher rule made a heading's span include every nested
+/// subsection beneath it, so a lone top-level `#` heading (the common case:
+/// one H1 title, many `##`/`###` children) spanned the entire rest of the
+/// document. A one-line change in the H1's own preamble then flagged that
+/// all-encompassing fragment as `role: "changed"`, dumping the whole file
+/// instead of just the touched paragraph (#91).
+fn find_section_end(headings: &[(u32, u32, String)], idx: usize, total_lines: u32) -> u32 {
+    match headings.get(idx + 1) {
+        Some(&(next_line, _, _)) => next_line - 1,
+        None => total_lines,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Regression for #91: a lone H1 title followed only by `##` children
+    /// must not produce a single fragment spanning the whole document — the
+    /// H1's own fragment is just its direct preamble, up to the first child.
+    #[test]
+    fn h1_fragment_stops_at_first_child_heading_not_eof() {
+        let content =
+            "# Title\n\nPreamble line.\n\n## Section One\nBody one.\n\n## Section Two\nBody two.\n";
+        let fragments = MarkdownStrategy.fragment(Arc::from("doc.md"), content);
+
+        let title = fragments
+            .iter()
+            .find(|f| f.content.starts_with("# Title"))
+            .expect("Title fragment present");
+        assert_eq!(title.id.start_line, 1);
+        assert_eq!(
+            title.id.end_line, 4,
+            "H1 fragment should stop before '## Section One', not run to EOF"
+        );
+    }
+
+    #[test]
+    fn sibling_headings_still_each_get_their_own_fragment() {
+        let content =
+            "## Section One\nBody one.\n\n## Section Two\nBody two.\n### Nested\nNested body.\n";
+        let fragments = MarkdownStrategy.fragment(Arc::from("doc.md"), content);
+        assert_eq!(fragments.len(), 3);
+
+        let nested = fragments
+            .iter()
+            .find(|f| f.content.starts_with("### Nested"))
+            .expect("Nested fragment present");
+        assert_eq!(nested.id.start_line, 6);
+        assert_eq!(nested.id.end_line, 8);
     }
-    total_lines
 }

{diffctx-1.10.1 → diffctx-1.10.2}/diffctx/src/pipeline.rs

@@ -131,6 +131,13 @@ pub fn compute_scored_state(
         return Ok(empty_scored_state(root_dir));
     }
 
+    let ignored_rel_paths = resolve_ignored_paths(&root_dir, &hunks);
+    hunks.retain(|h| !is_ignored_path(&root_dir, Path::new(&*h.path), &ignored_rel_paths));
+
+    if hunks.is_empty() {
+        return Ok(empty_scored_state(root_dir));
+    }
+
     let diff_text = git::get_diff_text(&root_dir, diff_range)?;
 
     let mut changed_files = git::get_changed_files(&root_dir, diff_range)?;
@@ -152,7 +159,9 @@ pub fn compute_scored_state(
         .into_iter()
         .filter(|f| {
             let resolved = f.canonicalize().unwrap_or_else(|_| f.clone());
-            !excluded.contains(&resolved) && !is_secret_path(f)
+            !excluded.contains(&resolved)
+                && !is_secret_path(f)
+                && !is_ignored_path(&root_dir, f, &ignored_rel_paths)
         })
         .collect();
 
@@ -494,6 +503,31 @@ fn is_secret_path(path: &Path) -> bool {
     )
 }
 
+fn rel_path_string(root_dir: &Path, path: &Path) -> Option<String> {
+    path.strip_prefix(root_dir)
+        .ok()
+        .map(|p| p.to_string_lossy().replace('\\', "/"))
+}
+
+/// Resolves `.gitignore` / `.diffctx/ignore` exclusions (#85) for every path
+/// touched by `hunks`, in one batched git call. diff mode previously only
+/// ever excluded a hardcoded set of secret-like filenames (`is_secret_path`)
+/// — a file a user explicitly excluded via `.diffctx/ignore` still had its
+/// changed content surfaced in full.
+fn resolve_ignored_paths(root_dir: &Path, hunks: &[crate::types::DiffHunk]) -> FxHashSet<String> {
+    let rel_paths: Vec<String> = hunks
+        .iter()
+        .filter_map(|h| rel_path_string(root_dir, Path::new(&*h.path)))
+        .collect();
+    git::find_ignored_paths(root_dir, &rel_paths)
+}
+
+fn is_ignored_path(root_dir: &Path, path: &Path, ignored_rel_paths: &FxHashSet<String>) -> bool {
+    rel_path_string(root_dir, path)
+        .map(|rel| ignored_rel_paths.contains(&rel))
+        .unwrap_or(false)
+}
+
 fn build_diff_context_full(
     root_dir: &Path,
     diff_range: Option<&str>,
@@ -513,8 +547,14 @@ fn build_diff_context_full(
     if hunks.is_empty() {
         return Ok(empty_output(&root_dir));
     }
+    let ignored_rel_paths = resolve_ignored_paths(&root_dir, &hunks);
+    hunks.retain(|h| !is_ignored_path(&root_dir, Path::new(&*h.path), &ignored_rel_paths));
+    if hunks.is_empty() {
+        return Ok(empty_output(&root_dir));
+    }
     let mut changed_files = git::get_changed_files(&root_dir, diff_range)?;
-    changed_files.retain(|f| !is_secret_path(f));
+    changed_files
+        .retain(|f| !is_secret_path(f) && !is_ignored_path(&root_dir, f, &ignored_rel_paths));
     if changed_files.is_empty() {
         return Ok(empty_output(&root_dir));
     }

{diffctx-1.10.1 → diffctx-1.10.2}/pyproject.toml

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

{diffctx-1.10.1 → diffctx-1.10.2}/src/diffctx/cli.py

@@ -24,17 +24,28 @@ class _Unset:
 _UNSET: _Unset = _Unset()
 _DIFF_SENTINEL = "__DIFFCTX_DIFF_BARE__"
 
+# Set once at the top of parse_args(); read by _exit_error/_warn so every
+# CLI-side validation message is branded like argparse's own native errors
+# (`{prog}: error: ...`) instead of a bare, unbranded "Error: ...". Module
+# state (rather than threading `prog` through every _validate_* signature)
+# keeps this a same-session fix; see #89.
+_current_prog: str = "diffctx"
+
 
 def _exit_error(message: str) -> NoReturn:
-    print(f"Error: {message}", file=sys.stderr)
+    print(f"{_current_prog}: error: {message}", file=sys.stderr)
     sys.exit(1)
 
 
+def _warn(message: str) -> None:
+    print(f"{_current_prog}: warning: {message}", file=sys.stderr)
+
+
 def _validate_max_depth(max_depth: int | None) -> None:
     if max_depth is not None and max_depth < 0:
         _exit_error(f"--max-depth must be non-negative, got {max_depth}")
     if max_depth == 0:
-        print("Warning: --max-depth 0 produces empty tree (root only, no children)", file=sys.stderr)
+        _warn("--max-depth 0 produces empty tree (root only, no children)")
 
 
 def _validate_max_file_bytes(max_file_bytes: int, no_file_size_limit: bool) -> int | None:
@@ -196,6 +207,7 @@ class ParsedArgs:
     graph: GraphArgs | None = None
     extra_dirs: list[Path] | None = None
     extra_files: list[Path] | None = None
+    no_explicit_paths: bool = False
 
 
 DEFAULT_IGNORES_HELP = """
@@ -230,6 +242,8 @@ Examples:
   diffctx . --diff HEAD~1      Show context for last commit
   diffctx . -c                 Copy output to clipboard
   diffctx . --no-content       Structure only, no file contents
+  diffctx graph .              Build the project dependency graph (see: diffctx graph --help)
+  diffctx graph . --summary    Print graph stats (cycles, hotspots, coupling)
 
 Output routing:
   Default:      stdout
@@ -303,7 +317,7 @@ def _build_main_parser(prog: str = "diffctx", version: str = __version__) -> arg
     )
 
     parser.add_argument("-v", "--version", action="version", version=f"%(prog)s {version}")
-    parser.add_argument("paths", nargs="*", default=["."], help="Directories, files, or glob patterns to analyze")
+    parser.add_argument("paths", nargs="*", default=[], help="Directories, files, or glob patterns to analyze")
     parser.add_argument(
         "-f",
         "--format",
@@ -360,7 +374,11 @@ def _build_main_parser(prog: str = "diffctx", version: str = __version__) -> arg
         type=float,
         default=_UNSET,
         metavar="F",
-        help="Minimum relevance to include a fragment (default: 0.12, typical 0-1; lower = more context, >1 keeps only changed code)",
+        help=(
+            "Minimum relevance to include a fragment (default: 0.12, typical range 0-1; "
+            "lower = more surrounding context. E.g. --tau 2 excludes nearly everything but "
+            "the changed code itself, since only directly-changed fragments score that high)"
+        ),
     )
     diff_group.add_argument(
         "--scoring",
@@ -393,7 +411,7 @@ def _warn_diff_only_flags(args: argparse.Namespace) -> None:
         used.append("--scoring")
     if used:
         flags = ", ".join(used)
-        print(f"Warning: diff-mode flags ignored without --diff: {flags}", file=sys.stderr)
+        _warn(f"diff-mode flags ignored without --diff: {flags}")
 
 
 def _build_graph_parsed_args(args: argparse.Namespace) -> ParsedArgs:
@@ -477,10 +495,13 @@ def _build_tree_parsed_args(args: argparse.Namespace) -> ParsedArgs:
         full_diff=args.full,
         extra_dirs=extra_dirs,
         extra_files=extra_files,
+        no_explicit_paths=not args.paths,
     )
 
 
 def parse_args(argv: list[str] | None = None, *, prog: str = "diffctx", version: str = __version__) -> ParsedArgs:
+    global _current_prog
+    _current_prog = prog
     raw_args = sys.argv[1:] if argv is None else argv
 
     if raw_args and raw_args[0] == "graph":

{diffctx-1.10.1 → diffctx-1.10.2}/src/diffctx/ignore.py

@@ -108,9 +108,17 @@ def _process_ignore_line(line: str, rel: str) -> str:
     return ("!" + full) if neg else full
 
 
+_DIFFCTX_IGNORE_RELPATH = f"{DIFFCTX_CONFIG_DIR}/{DIFFCTX_DIR_IGNORE}"
+
+
 def _collect_from_git(ignore_files: list[Path], root: Path, out: list[str]) -> None:
     for ignore_path in ignore_files:
-        ignore_dir = ignore_path.parent
+        # .diffctx/ignore patterns are relative to the directory that
+        # *contains* .diffctx/, not to .diffctx/ itself.
+        if ignore_path.parent.name == DIFFCTX_CONFIG_DIR and ignore_path.name == DIFFCTX_DIR_IGNORE:
+            ignore_dir = ignore_path.parent.parent
+        else:
+            ignore_dir = ignore_path.parent
         rel = "" if ignore_dir == root else ignore_dir.relative_to(root).as_posix()
         for line in read_ignore_file(ignore_path):
             out.append(_process_ignore_line(line, rel))
@@ -146,9 +154,14 @@ def _aggregate_all_ignore_patterns(root: Path, ignore_filenames: list[str]) -> l
 def _find_ignore_files_via_git(root: Path, ignore_filenames: list[str]) -> list[Path] | None:
     import subprocess
 
+    # A bare filename pathspec (e.g. ".gitignore") only matches that exact
+    # path relative to `root` — it does NOT find nested occurrences. Use
+    # glob-magic pathspecs so nested .gitignore / .diffctx/ignore files are
+    # discovered the same way _collect_from_walk's os.walk fallback finds them.
+    pathspecs = [f":(glob)**/{name}" for name in ignore_filenames]
     try:
         result = subprocess.run(
-            ["git", "ls-files", "-z", "--cached", "--others", "--exclude-standard", "--", *ignore_filenames],
+            ["git", "ls-files", "-z", "--cached", "--others", "--exclude-standard", "--", *pathspecs],
             cwd=root,
             capture_output=True,
             text=False,
@@ -315,7 +328,7 @@ def get_ignore_specs(
         patterns.extend(DEFAULT_IGNORE_PATTERNS)
 
     patterns.extend(_collect_parent_ignore_patterns(root_dir, [".gitignore"]))
-    patterns.extend(_aggregate_all_ignore_patterns(root_dir, [".gitignore"]))
+    patterns.extend(_aggregate_all_ignore_patterns(root_dir, [".gitignore", _DIFFCTX_IGNORE_RELPATH]))
 
     if custom_ignore_file:
         patterns.extend(read_ignore_file(custom_ignore_file))

{diffctx-1.10.1 → diffctx-1.10.2}/src/diffctx/main.py

@@ -31,7 +31,7 @@ def _configure_windows_utf8() -> None:
         pass
 
 
-def _ensure_git_repo(root_dir: Path) -> None:
+def _ensure_git_repo(root_dir: Path, prog: str) -> None:
     try:
         result = subprocess.run(
             ["git", "rev-parse", "--git-dir"],
@@ -42,18 +42,33 @@ def _ensure_git_repo(root_dir: Path) -> None:
         )
     except OSError as exc:
         print(
-            f"diffctx: --diff requires git to be installed and on PATH ({exc}); install git or run without --diff.",
+            f"{prog}: --diff requires git to be installed and on PATH ({exc}); install git or run without --diff.",
             file=sys.stderr,
         )
         sys.exit(_EXIT_ENVIRONMENT)
     if result.returncode != 0:
         print(
-            f"diffctx: --diff requires a git repository (cwd: {root_dir}); "
+            f"{prog}: --diff requires a git repository (cwd: {root_dir}); "
             "run inside a working tree or pass --diff <range> with a valid git context.",
             file=sys.stderr,
         )
         sys.exit(_EXIT_ENVIRONMENT)
 
+    head_result = subprocess.run(
+        ["git", "rev-parse", "--verify", "-q", "HEAD"],
+        cwd=str(root_dir),
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        check=False,
+    )
+    if head_result.returncode != 0:
+        print(
+            f"{prog}: --diff requires at least one commit (no HEAD in this repository yet); "
+            "commit first, or run without --diff to map the working tree.",
+            file=sys.stderr,
+        )
+        sys.exit(_EXIT_ENVIRONMENT)
+
 
 def _diff_result_is_empty(result: dict[str, Any]) -> bool:
     count = result.get("fragment_count")
@@ -65,21 +80,21 @@ def _diff_result_is_empty(result: dict[str, Any]) -> bool:
     return False
 
 
-def _warn_empty_diff_result(result: dict[str, Any]) -> None:
+def _warn_empty_diff_result(result: dict[str, Any], prog: str) -> None:
     if _diff_result_is_empty(result):
         print(
-            "diffctx: diff produced no semantic context "
+            f"{prog}: diff produced no semantic context "
             "(pure deletion, binary-only, or all files exceeded size cap); output empty.",
             file=sys.stderr,
         )
 
 
-def _build_diff_tree(args: ParsedArgs) -> dict[str, Any]:
+def _build_diff_tree(args: ParsedArgs, prog: str) -> dict[str, Any]:
     from .diffctx import build_diff_context
 
     if not args.diff_range:
         raise RuntimeError("diff_range is required in diff mode")
-    _ensure_git_repo(args.root_dir)
+    _ensure_git_repo(args.root_dir, prog)
     result = build_diff_context(
         root_dir=args.root_dir,
         diff_range=args.diff_range,
@@ -93,7 +108,7 @@ def _build_diff_tree(args: ParsedArgs) -> dict[str, Any]:
         whitelist_file=args.whitelist_file,
         scoring_mode=getattr(args, "scoring", "ego"),
     )
-    _warn_empty_diff_result(result)
+    _warn_empty_diff_result(result, prog)
     return result
 
 
@@ -103,13 +118,19 @@ def _root_display_name(root_dir: Any) -> str:
 
 
 _LARGE_OUTPUT_WARN_BYTES = 10 * 1024 * 1024
+# A bare `diffctx` with no path argument at all is the most common "just try
+# it" first invocation — and the easiest to run somewhere unintended (e.g.
+# /tmp, $HOME). Use a much lower bar for that specific case; an explicit path
+# argument is a stronger signal the user knows what they're pointing at (#87).
+_LARGE_OUTPUT_WARN_BYTES_NO_EXPLICIT_PATH = 1 * 1024 * 1024
 
 
 def _warn_if_output_oversized(output_content: str, args: ParsedArgs) -> None:
     if args.no_content or args.diff_range:
         return
+    threshold = _LARGE_OUTPUT_WARN_BYTES_NO_EXPLICIT_PATH if args.no_explicit_paths else _LARGE_OUTPUT_WARN_BYTES
     size_bytes = len(output_content.encode("utf-8"))
-    if size_bytes < _LARGE_OUTPUT_WARN_BYTES:
+    if size_bytes < threshold:
         return
     mb = size_bytes / (1024 * 1024)
     print(
@@ -312,7 +333,7 @@ def _run(argv: list[str] | None = None, *, prog: str = "diffctx", version: str =
             sys.stdout.write(output_content)
         return
 
-    directory_tree = _build_diff_tree(args) if args.diff_range else _build_standard_tree(args)
+    directory_tree = _build_diff_tree(args, prog) if args.diff_range else _build_standard_tree(args)
 
     output_content = tree_to_string(directory_tree, args.output_format)
     if not args.quiet:

{diffctx-1.10.1 → diffctx-1.10.2}/src/diffctx/mcp/__main__.py

@@ -1,9 +1,16 @@
 from __future__ import annotations
 
+import argparse
 import sys
 
 
 def main(prog: str = "diffctx-mcp", extra: str = "diffctx[mcp]") -> None:
+    parser = argparse.ArgumentParser(
+        prog=prog,
+        description="Run the diffctx MCP server (stdio transport) for editor/agent integration.",
+    )
+    parser.parse_args()
+
     try:
         from diffctx.mcp.server import run_server
     except ImportError:

diffctx-1.10.2/src/diffctx/version.py

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

diffctx-1.10.1/src/diffctx/version.py

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