claude-commit 0.6.0__tar.gz → 0.7.0__tar.gz

{claude_commit-0.6.0/src/claude_commit.egg-info → claude_commit-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-commit
-Version: 0.6.0
+Version: 0.7.0
 Summary: AI-powered git commit message generator using Claude Agent SDK
 Author-email: Johannlai <johannli666@gmail.com>
 License: MIT

{claude_commit-0.6.0 → claude_commit-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-commit"
-version = "0.6.0"
+version = "0.7.0"
 description = "AI-powered git commit message generator using Claude Agent SDK"
 readme = "README.md"
 requires-python = ">=3.9"

{claude_commit-0.6.0 → claude_commit-0.7.0}/src/claude_commit/main.py

@@ -32,6 +32,75 @@ from rich.progress import Progress, SpinnerColumn, TextColumn
 from .config import Config, resolve_alias
 
 console = Console()
+error_console = Console(stderr=True)
+
+
+def extract_commit_message(all_text: list) -> Optional[str]:
+    """Extract commit message from collected AI response text blocks.
+
+    Looks for the COMMIT_MESSAGE: marker first. Falls back to using the last
+    text block that doesn't start with an explanatory prefix.
+
+    Args:
+        all_text: List of text blocks from the AI response.
+
+    Returns:
+        Extracted commit message or None.
+    """
+    full_response = "\n".join(all_text)
+    commit_message = None
+
+    if "COMMIT_MESSAGE:" in full_response:
+        parts = full_response.split("COMMIT_MESSAGE:", 1)
+        if len(parts) > 1:
+            commit_message = parts[1].strip()
+    else:
+        for text in reversed(all_text):
+            text = text.strip()
+            if text and not any(
+                text.lower().startswith(prefix)
+                for prefix in [
+                    "let me",
+                    "i'll",
+                    "i will",
+                    "now i",
+                    "first",
+                    "i can see",
+                ]
+            ):
+                commit_message = text
+                break
+
+    if commit_message:
+        commit_message = clean_markdown_fences(commit_message)
+
+    return commit_message
+
+
+def clean_markdown_fences(text: str) -> str:
+    """Remove markdown code block fences from text, keeping content outside fences.
+
+    Lines starting with ``` toggle a "code block" state. Lines inside code blocks
+    are dropped; lines outside are kept.
+
+    Args:
+        text: Text potentially containing markdown code fences.
+
+    Returns:
+        Cleaned text with fences and their content removed.
+    """
+    lines = text.split("\n")
+    cleaned_lines = []
+    in_code_block = False
+
+    for line in lines:
+        if line.strip().startswith("```"):
+            in_code_block = not in_code_block
+            continue
+        if not in_code_block:
+            cleaned_lines.append(line.rstrip())
+
+    return "\n".join(cleaned_lines).strip()
 
 
 SYSTEM_PROMPT = """You are an expert software engineer tasked with analyzing code changes and writing excellent git commit messages.
@@ -431,48 +500,7 @@ Begin your analysis now.
                     console.print(f"[cyan]🔄 Turns: {message.num_turns}[/cyan]")
 
                 if not message.is_error:
-                    # Extract commit message from COMMIT_MESSAGE: marker
-                    full_response = "\n".join(all_text)
-
-                    # Look for COMMIT_MESSAGE: marker
-                    if "COMMIT_MESSAGE:" in full_response:
-                        # Extract everything after COMMIT_MESSAGE:
-                        parts = full_response.split("COMMIT_MESSAGE:", 1)
-                        if len(parts) > 1:
-                            commit_message = parts[1].strip()
-                    else:
-                        # Fallback: try to extract the last meaningful text block
-                        # Skip explanatory text and get the actual commit message
-                        for text in reversed(all_text):
-                            text = text.strip()
-                            if text and not any(
-                                text.lower().startswith(prefix)
-                                for prefix in [
-                                    "let me",
-                                    "i'll",
-                                    "i will",
-                                    "now i",
-                                    "first",
-                                    "i can see",
-                                ]
-                            ):
-                                commit_message = text
-                                break
-
-                    # Clean up markdown code blocks if present
-                    if commit_message:
-                        lines = commit_message.split("\n")
-                        cleaned_lines = []
-                        in_code_block = False
-
-                        for line in lines:
-                            if line.strip().startswith("```"):
-                                in_code_block = not in_code_block
-                                continue
-                            if not in_code_block:
-                                cleaned_lines.append(line.rstrip())
-
-                        commit_message = "\n".join(cleaned_lines).strip()
+                    commit_message = extract_commit_message(all_text)
 
         # Make sure progress is stopped before returning
         if progress is not None and task_id is not None:
@@ -490,23 +518,29 @@ Begin your analysis now.
         # Stop progress on error
         if "progress" in locals() and progress is not None:
             progress.stop()
-        console.print("[red]❌ Error: Claude Code CLI not found.[/red]", file=sys.stderr)
-        console.print(
-            "[yellow]📦 Please install it: npm install -g @anthropic-ai/claude-code[/yellow]",
-            file=sys.stderr,
+        error_console.print("[red]❌ Error: Claude Code CLI not found.[/red]")
+        error_console.print(
+            "[yellow]📦 Please install it: npm install -g @anthropic-ai/claude-code[/yellow]"
         )
         return None
     except ProcessError as e:
         if "progress" in locals() and progress is not None:
             progress.stop()
-        console.print(f"[red]❌ Process error: {e}[/red]", file=sys.stderr)
+        # If we already extracted a commit message, return it despite the process error
+        if commit_message:
+            return commit_message
+        error_console.print(f"[red]❌ Process error: {e}[/red]")
         if e.stderr:
-            console.print(f"   stderr: {e.stderr}", file=sys.stderr)
+            error_console.print(f"   stderr: {e.stderr}")
         return None
     except Exception as e:
         if "progress" in locals() and progress is not None:
             progress.stop()
-        console.print(f"[red]❌ Unexpected error: {e}[/red]", file=sys.stderr)
+        # If we already extracted a commit message, return it despite the error
+        # (the SDK sometimes raises after the CLI has already completed successfully)
+        if commit_message:
+            return commit_message
+        error_console.print(f"[red]❌ Unexpected error: {e}[/red]")
         if verbose:
             import traceback
 
@@ -947,11 +981,11 @@ Alias Management:
             )
         )
     except KeyboardInterrupt:
-        console.print("\n[yellow]⚠️  Interrupted by user[/yellow]", file=sys.stderr)
+        error_console.print("\n[yellow]⚠️  Interrupted by user[/yellow]")
         sys.exit(130)
 
     if not commit_message:
-        console.print("[red]❌ Failed to generate commit message[/red]", file=sys.stderr)
+        error_console.print("[red]❌ Failed to generate commit message[/red]")
         sys.exit(1)
 
     # Display the generated message with rich formatting
@@ -975,9 +1009,7 @@ Alias Management:
             pyperclip.copy(commit_message)
             console.print("\n[green]✅ Commit message copied to clipboard![/green]")
         except Exception as e:
-            console.print(
-                f"\n[yellow]⚠️  Failed to copy to clipboard: {e}[/yellow]", file=sys.stderr
-            )
+            error_console.print(f"\n[yellow]⚠️  Failed to copy to clipboard: {e}[/yellow]")
 
     if args.commit:
         try:
@@ -1004,12 +1036,12 @@ Alias Management:
             if result.stdout:
                 console.print(result.stdout)
         except subprocess.CalledProcessError as e:
-            console.print(f"\n[red]❌ Failed to commit: {e}[/red]", file=sys.stderr)
+            error_console.print(f"\n[red]❌ Failed to commit: {e}[/red]")
             if e.stderr:
-                console.print(e.stderr, file=sys.stderr)
+                error_console.print(e.stderr)
             sys.exit(1)
         except Exception as e:
-            console.print(f"\n[red]❌ Unexpected error during commit: {e}[/red]", file=sys.stderr)
+            error_console.print(f"\n[red]❌ Unexpected error during commit: {e}[/red]")
             sys.exit(1)
     else:
         # Default: just show the command

{claude_commit-0.6.0 → claude_commit-0.7.0/src/claude_commit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-commit
-Version: 0.6.0
+Version: 0.7.0
 Summary: AI-powered git commit message generator using Claude Agent SDK
 Author-email: Johannlai <johannli666@gmail.com>
 License: MIT

{claude_commit-0.6.0 → claude_commit-0.7.0}/src/claude_commit.egg-info/SOURCES.txt

@@ -9,4 +9,6 @@ src/claude_commit.egg-info/SOURCES.txt
 src/claude_commit.egg-info/dependency_links.txt
 src/claude_commit.egg-info/entry_points.txt
 src/claude_commit.egg-info/requires.txt
-src/claude_commit.egg-info/top_level.txt
+src/claude_commit.egg-info/top_level.txt
+tests/test_config.py
+tests/test_main.py

claude_commit-0.7.0/tests/test_config.py

@@ -0,0 +1,182 @@
+"""Tests for claude_commit.config — Config class and resolve_alias."""
+
+import json
+from pathlib import Path
+
+import pytest
+
+from claude_commit.config import Config, resolve_alias
+
+
+# ---------------------------------------------------------------------------
+# Config – defaults
+# ---------------------------------------------------------------------------
+
+
+class TestConfigDefaults:
+    def test_new_config_has_default_aliases(self, tmp_path):
+        cfg = Config(config_path=tmp_path / "config.json")
+        aliases = cfg.list_aliases()
+        assert "cc" in aliases
+        assert "ccc" in aliases
+        assert "cca" in aliases
+
+    def test_default_alias_values(self, tmp_path):
+        cfg = Config(config_path=tmp_path / "config.json")
+        assert cfg.get_alias("cc") == ""
+        assert cfg.get_alias("ccc") == "--commit"
+        assert cfg.get_alias("cca") == "--all"
+        assert cfg.get_alias("ccac") == "--all --commit"
+
+
+# ---------------------------------------------------------------------------
+# Config – set / get / delete / list
+# ---------------------------------------------------------------------------
+
+
+class TestConfigAliasOps:
+    def test_set_and_get_alias(self, tmp_path):
+        cfg = Config(config_path=tmp_path / "config.json")
+        cfg.set_alias("myalias", "--all --verbose")
+        assert cfg.get_alias("myalias") == "--all --verbose"
+
+    def test_get_alias_returns_none_for_unknown(self, tmp_path):
+        cfg = Config(config_path=tmp_path / "config.json")
+        assert cfg.get_alias("nonexistent") is None
+
+    def test_delete_alias_existing(self, tmp_path):
+        cfg = Config(config_path=tmp_path / "config.json")
+        cfg.set_alias("tmp", "--verbose")
+        assert cfg.delete_alias("tmp") is True
+        assert cfg.get_alias("tmp") is None
+
+    def test_delete_alias_missing(self, tmp_path):
+        cfg = Config(config_path=tmp_path / "config.json")
+        assert cfg.delete_alias("does_not_exist") is False
+
+    def test_list_aliases_returns_copy(self, tmp_path):
+        cfg = Config(config_path=tmp_path / "config.json")
+        aliases = cfg.list_aliases()
+        aliases["injected"] = "evil"
+        assert cfg.get_alias("injected") is None
+
+
+# ---------------------------------------------------------------------------
+# Config – first run
+# ---------------------------------------------------------------------------
+
+
+class TestConfigFirstRun:
+    def test_is_first_run_true_when_no_file(self, tmp_path):
+        cfg = Config(config_path=tmp_path / "config.json")
+        assert cfg.is_first_run() is True
+
+    def test_is_first_run_false_after_save(self, tmp_path):
+        path = tmp_path / "config.json"
+        cfg = Config(config_path=path)
+        cfg.mark_first_run_complete()
+        assert cfg.is_first_run() is False
+
+    def test_mark_first_run_creates_file(self, tmp_path):
+        path = tmp_path / "subdir" / "config.json"
+        cfg = Config(config_path=path)
+        cfg.mark_first_run_complete()
+        assert path.exists()
+
+    def test_mark_first_run_idempotent(self, tmp_path):
+        path = tmp_path / "config.json"
+        cfg = Config(config_path=path)
+        cfg.mark_first_run_complete()
+        content1 = path.read_text()
+        cfg.mark_first_run_complete()  # second call should be a no-op
+        content2 = path.read_text()
+        assert content1 == content2
+
+
+# ---------------------------------------------------------------------------
+# Config – persistence across instances
+# ---------------------------------------------------------------------------
+
+
+class TestConfigPersistence:
+    def test_alias_persists_across_instances(self, tmp_path):
+        path = tmp_path / "config.json"
+        cfg1 = Config(config_path=path)
+        cfg1.set_alias("persist", "--all --commit")
+
+        cfg2 = Config(config_path=path)
+        assert cfg2.get_alias("persist") == "--all --commit"
+
+    def test_config_file_is_valid_json(self, tmp_path):
+        path = tmp_path / "config.json"
+        cfg = Config(config_path=path)
+        cfg.set_alias("test", "--verbose")
+        data = json.loads(path.read_text())
+        assert "aliases" in data
+        assert data["aliases"]["test"] == "--verbose"
+
+    def test_corrupt_config_file_returns_defaults(self, tmp_path):
+        path = tmp_path / "config.json"
+        path.write_text("not valid json!!!")
+        cfg = Config(config_path=path)
+        # Should fall back to defaults without raising
+        assert "cc" in cfg.list_aliases()
+
+
+# ---------------------------------------------------------------------------
+# resolve_alias
+# ---------------------------------------------------------------------------
+
+
+class TestResolveAlias:
+    def test_empty_args_returns_empty(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(
+            "claude_commit.config.Config.__init__",
+            lambda self, config_path=None: Config.__init__(
+                self, config_path=tmp_path / "config.json"
+            ),
+        )
+        assert resolve_alias([]) == []
+
+    def test_known_alias_expands(self, tmp_path, monkeypatch):
+        path = tmp_path / "config.json"
+        cfg = Config(config_path=path)
+        cfg.set_alias("myalias", "--all --verbose")
+
+        # Patch Config() inside resolve_alias to use our tmp config
+        original_init = Config.__init__
+
+        def patched_init(self, config_path=None):
+            original_init(self, config_path=path)
+
+        monkeypatch.setattr("claude_commit.config.Config.__init__", patched_init)
+
+        result = resolve_alias(["myalias", "--extra"])
+        assert result == ["--all", "--verbose", "--extra"]
+
+    def test_empty_alias_drops_alias_arg(self, tmp_path, monkeypatch):
+        path = tmp_path / "config.json"
+        cfg = Config(config_path=path)
+        cfg.set_alias("bare", "")
+
+        original_init = Config.__init__
+
+        def patched_init(self, config_path=None):
+            original_init(self, config_path=path)
+
+        monkeypatch.setattr("claude_commit.config.Config.__init__", patched_init)
+
+        result = resolve_alias(["bare", "--verbose"])
+        assert result == ["--verbose"]
+
+    def test_unknown_arg_passes_through(self, tmp_path, monkeypatch):
+        path = tmp_path / "config.json"
+        original_init = Config.__init__
+
+        def patched_init(self, config_path=None):
+            original_init(self, config_path=path)
+
+        monkeypatch.setattr("claude_commit.config.Config.__init__", patched_init)
+
+        result = resolve_alias(["--all", "--verbose"])
+        assert result == ["--all", "--verbose"]

claude_commit-0.7.0/tests/test_main.py

@@ -0,0 +1,315 @@
+"""Tests for claude_commit.main — pure logic (no Claude / git calls)."""
+
+import sys
+from unittest.mock import patch
+
+import pytest
+
+from claude_commit.config import Config
+from claude_commit.main import (
+    clean_markdown_fences,
+    extract_commit_message,
+    handle_alias_command,
+)
+
+
+# ---------------------------------------------------------------------------
+# extract_commit_message — COMMIT_MESSAGE: marker
+# ---------------------------------------------------------------------------
+
+
+class TestExtractCommitMessage:
+    def test_extracts_after_marker(self):
+        all_text = [
+            "Let me analyze the changes.",
+            "COMMIT_MESSAGE:\nfeat: add login\n\n- Add JWT auth",
+        ]
+        result = extract_commit_message(all_text)
+        assert result is not None
+        assert result.startswith("feat: add login")
+        assert "- Add JWT auth" in result
+
+    def test_marker_in_middle_of_text(self):
+        all_text = [
+            "Analysis done. COMMIT_MESSAGE:\nfix: typo in README",
+        ]
+        result = extract_commit_message(all_text)
+        assert result == "fix: typo in README"
+
+    def test_marker_across_text_blocks(self):
+        all_text = [
+            "Some analysis",
+            "More analysis\nCOMMIT_MESSAGE:\nchore: bump version",
+        ]
+        result = extract_commit_message(all_text)
+        assert result == "chore: bump version"
+
+    def test_only_first_marker_used(self):
+        all_text = [
+            "COMMIT_MESSAGE:\nfirst message",
+            "COMMIT_MESSAGE:\nsecond message",
+        ]
+        result = extract_commit_message(all_text)
+        assert "first message" in result
+
+    def test_returns_none_for_empty_input(self):
+        assert extract_commit_message([]) is None
+
+    def test_returns_none_for_only_explanatory_text(self):
+        all_text = [
+            "Let me analyze the changes.",
+            "I'll look at the diff now.",
+            "First, checking git status.",
+        ]
+        result = extract_commit_message(all_text)
+        assert result is None
+
+
+# ---------------------------------------------------------------------------
+# extract_commit_message — fallback (no marker)
+# ---------------------------------------------------------------------------
+
+
+class TestExtractFallback:
+    def test_uses_last_non_explanatory_block(self):
+        all_text = [
+            "Let me analyze.",
+            "feat: add new feature",
+            "I'll commit this now.",
+        ]
+        # "I'll commit this now." starts with "i'll" → skipped
+        # "feat: add new feature" → used
+        result = extract_commit_message(all_text)
+        assert result == "feat: add new feature"
+
+    def test_skips_all_known_prefixes(self):
+        prefixes = ["let me", "i'll", "i will", "now i", "first", "i can see"]
+        for prefix in prefixes:
+            all_text = [f"{prefix} do something"]
+            result = extract_commit_message(all_text)
+            assert result is None, f"Should skip prefix: {prefix}"
+
+    def test_prefix_check_is_case_insensitive(self):
+        all_text = ["Let Me analyze the diff"]
+        result = extract_commit_message(all_text)
+        assert result is None
+
+    def test_non_prefix_text_is_accepted(self):
+        all_text = ["refactor: clean up imports"]
+        result = extract_commit_message(all_text)
+        assert result == "refactor: clean up imports"
+
+
+# ---------------------------------------------------------------------------
+# clean_markdown_fences
+# ---------------------------------------------------------------------------
+
+
+class TestCleanMarkdownFences:
+    def test_no_fences_unchanged(self):
+        text = "feat: add login\n\n- Add JWT auth"
+        assert clean_markdown_fences(text) == text
+
+    def test_strips_surrounding_fences(self):
+        # Content outside fences is kept; content inside is dropped.
+        # So fences around extra examples are removed.
+        text = "feat: add login\n\n```\ngit commit -m 'feat: add login'\n```"
+        result = clean_markdown_fences(text)
+        assert "```" not in result
+        assert "feat: add login" in result
+        assert "git commit" not in result
+
+    def test_strips_fences_with_language_tag(self):
+        text = "fix: typo\n\n```bash\nsome command\n```"
+        result = clean_markdown_fences(text)
+        assert "```" not in result
+        assert "some command" not in result
+        assert "fix: typo" in result
+
+    def test_multiple_fenced_blocks(self):
+        text = "header\n```\nblock1\n```\nmiddle\n```\nblock2\n```\nfooter"
+        result = clean_markdown_fences(text)
+        assert result == "header\nmiddle\nfooter"
+
+    def test_empty_string(self):
+        assert clean_markdown_fences("") == ""
+
+    def test_only_fences(self):
+        assert clean_markdown_fences("```\nhello\n```") == ""
+
+
+# ---------------------------------------------------------------------------
+# handle_alias_command
+# ---------------------------------------------------------------------------
+
+
+class TestHandleAliasCommand:
+    def _make_config(self, tmp_path):
+        """Create a Config with a temp path and patch Config() calls."""
+        return Config(config_path=tmp_path / "config.json")
+
+    def test_list_aliases(self, tmp_path, capsys, monkeypatch):
+        path = tmp_path / "config.json"
+        original_init = Config.__init__
+
+        def patched_init(self, config_path=None):
+            original_init(self, config_path=path)
+
+        monkeypatch.setattr(Config, "__init__", patched_init)
+
+        handle_alias_command(["list"])
+        captured = capsys.readouterr()
+        assert "Configured aliases" in captured.out
+        assert "ccc" in captured.out
+
+    def test_list_aliases_default(self, tmp_path, capsys, monkeypatch):
+        """Calling with no args defaults to list."""
+        path = tmp_path / "config.json"
+        original_init = Config.__init__
+
+        def patched_init(self, config_path=None):
+            original_init(self, config_path=path)
+
+        monkeypatch.setattr(Config, "__init__", patched_init)
+
+        handle_alias_command([])
+        captured = capsys.readouterr()
+        assert "Configured aliases" in captured.out
+
+    def test_set_alias(self, tmp_path, capsys, monkeypatch):
+        path = tmp_path / "config.json"
+        original_init = Config.__init__
+
+        def patched_init(self, config_path=None):
+            original_init(self, config_path=path)
+
+        monkeypatch.setattr(Config, "__init__", patched_init)
+
+        handle_alias_command(["set", "myalias", "--all", "--verbose"])
+        captured = capsys.readouterr()
+        assert "myalias" in captured.out
+
+        # Verify it was persisted
+        cfg = Config(config_path=path)
+        assert cfg.get_alias("myalias") == "--all --verbose"
+
+    def test_set_alias_missing_name(self, tmp_path, monkeypatch):
+        path = tmp_path / "config.json"
+        original_init = Config.__init__
+
+        def patched_init(self, config_path=None):
+            original_init(self, config_path=path)
+
+        monkeypatch.setattr(Config, "__init__", patched_init)
+
+        with pytest.raises(SystemExit):
+            handle_alias_command(["set"])
+
+    def test_unset_alias(self, tmp_path, capsys, monkeypatch):
+        path = tmp_path / "config.json"
+        cfg = Config(config_path=path)
+        cfg.set_alias("removeme", "--verbose")
+
+        original_init = Config.__init__
+
+        def patched_init(self, config_path=None):
+            original_init(self, config_path=path)
+
+        monkeypatch.setattr(Config, "__init__", patched_init)
+
+        handle_alias_command(["unset", "removeme"])
+        captured = capsys.readouterr()
+        assert "removeme" in captured.out
+        assert "removed" in captured.out
+
+    def test_unset_alias_not_found(self, tmp_path, monkeypatch):
+        path = tmp_path / "config.json"
+        original_init = Config.__init__
+
+        def patched_init(self, config_path=None):
+            original_init(self, config_path=path)
+
+        monkeypatch.setattr(Config, "__init__", patched_init)
+
+        with pytest.raises(SystemExit):
+            handle_alias_command(["unset", "ghost"])
+
+    def test_unknown_subcommand(self, tmp_path, monkeypatch):
+        path = tmp_path / "config.json"
+        original_init = Config.__init__
+
+        def patched_init(self, config_path=None):
+            original_init(self, config_path=path)
+
+        monkeypatch.setattr(Config, "__init__", patched_init)
+
+        with pytest.raises(SystemExit):
+            handle_alias_command(["bogus"])
+
+
+# ---------------------------------------------------------------------------
+# Argument parsing
+# ---------------------------------------------------------------------------
+
+
+class TestArgumentParsing:
+    """Test argparse defaults and flag behaviour by importing the parser setup."""
+
+    def _parse(self, args):
+        """Build the parser identical to main() and parse args."""
+        import argparse
+        from pathlib import Path
+
+        parser = argparse.ArgumentParser()
+        parser.add_argument("-a", "--all", action="store_true")
+        parser.add_argument("-v", "--verbose", action="store_true")
+        parser.add_argument("-p", "--path", type=Path, default=None)
+        parser.add_argument("--max-diff-lines", type=int, default=500)
+        parser.add_argument("-c", "--commit", action="store_true")
+        parser.add_argument("--copy", action="store_true")
+        parser.add_argument("--preview", action="store_true")
+        return parser.parse_args(args)
+
+    def test_defaults(self):
+        ns = self._parse([])
+        assert ns.all is False
+        assert ns.verbose is False
+        assert ns.path is None
+        assert ns.max_diff_lines == 500
+        assert ns.commit is False
+        assert ns.copy is False
+        assert ns.preview is False
+
+    def test_all_flag(self):
+        for flag in ["-a", "--all"]:
+            ns = self._parse([flag])
+            assert ns.all is True
+
+    def test_verbose_flag(self):
+        for flag in ["-v", "--verbose"]:
+            ns = self._parse([flag])
+            assert ns.verbose is True
+
+    def test_commit_flag(self):
+        for flag in ["-c", "--commit"]:
+            ns = self._parse([flag])
+            assert ns.commit is True
+
+    def test_copy_flag(self):
+        ns = self._parse(["--copy"])
+        assert ns.copy is True
+
+    def test_preview_flag(self):
+        ns = self._parse(["--preview"])
+        assert ns.preview is True
+
+    def test_max_diff_lines(self):
+        ns = self._parse(["--max-diff-lines", "1000"])
+        assert ns.max_diff_lines == 1000
+
+    def test_combined_flags(self):
+        ns = self._parse(["-a", "-v", "-c", "--max-diff-lines", "200"])
+        assert ns.all is True
+        assert ns.verbose is True
+        assert ns.commit is True
+        assert ns.max_diff_lines == 200