crackerjack 0.20.20__py3-none-any.whl → 0.21.0__py3-none-any.whl

crackerjack/.pre-commit-config.yaml

@@ -26,7 +26,7 @@ repos:
 
   # Package management - once structure is valid
   - repo: https://github.com/pdm-project/pdm
-    rev: 2.24.2
+    rev: 2.25.3
     hooks:
       - id: pdm-lock-check
       - id: pdm-sync
@@ -34,7 +34,7 @@ repos:
           - keyring
 
   - repo: https://github.com/astral-sh/uv-pre-commit
-    rev: 0.7.12
+    rev: 0.7.15
     hooks:
       - id: uv-lock
         files: ^pyproject\.toml$
@@ -55,7 +55,7 @@ repos:
           - tomli
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.11.13
+    rev: v0.12.1
     hooks:
       - id: ruff-check
       - id: ruff-format
@@ -71,6 +71,12 @@ repos:
     hooks:
       - id: creosote
 
+  - repo: https://github.com/rohaquinlop/complexipy-pre-commit
+    rev: v3.0.0
+    hooks:
+      - id: complexipy
+        args: ["-d", "low"]
+
   - repo: https://github.com/dosisod/refurb
     rev: v2.1.0
     hooks:
@@ -95,7 +101,7 @@ repos:
           - libcst>=1.1.0
 
   - repo: https://github.com/PyCQA/bandit
-    rev: '1.8.3'
+    rev: '1.8.5'
     hooks:
       - id: bandit
         args: ["-c", "pyproject.toml"]

crackerjack/__main__.py

@@ -40,7 +40,6 @@ class Options(BaseModel):
     ai_agent: bool = False
     create_pr: bool = False
     skip_hooks: bool = False
-    rich_ui: bool = False
 
     @classmethod
     @field_validator("publish", "bump", mode="before")
@@ -59,7 +58,10 @@ class Options(BaseModel):
 cli_options = {
     "commit": typer.Option(False, "-c", "--commit", help="Commit changes to Git."),
     "interactive": typer.Option(
-        False, "-i", "--interactive", help="Run pre-commit hooks interactively."
+        False,
+        "-i",
+        "--interactive",
+        help="Use the interactive Rich UI for a better experience.",
     ),
     "doc": typer.Option(False, "-d", "--doc", help="Generate documentation."),
     "no_config_updates": typer.Option(
@@ -131,9 +133,6 @@ cli_options = {
     "create_pr": typer.Option(
         False, "-r", "--pr", help="Create a pull request to the upstream repository."
     ),
-    "rich_ui": typer.Option(
-        False, "--rich-ui", help="Use the interactive Rich UI for a better experience."
-    ),
     "ai_agent": typer.Option(
         False,
         "--ai-agent",
@@ -165,7 +164,6 @@ def main(
     test_timeout: int = cli_options["test_timeout"],
     skip_hooks: bool = cli_options["skip_hooks"],
     create_pr: bool = cli_options["create_pr"],
-    rich_ui: bool = cli_options["rich_ui"],
     ai_agent: bool = cli_options["ai_agent"],
 ) -> None:
     options = Options(
@@ -188,13 +186,12 @@ def main(
         all=all,
         ai_agent=ai_agent,
         create_pr=create_pr,
-        rich_ui=rich_ui,
     )
     if ai_agent:
         import os
 
         os.environ["AI_AGENT"] = "1"
-    if rich_ui:
+    if interactive:
         from crackerjack.interactive import launch_interactive_cli
 
         try:

crackerjack/crackerjack.py

@@ -13,7 +13,6 @@ from tomli_w import dumps
 from crackerjack.errors import ErrorCode, ExecutionError
 
 config_files = (".gitignore", ".pre-commit-config.yaml", ".libcst.codemod.yaml")
-interactive_hooks = ("refurb", "bandit", "pyright")
 default_python_version = "3.13"
 
 
@@ -85,36 +84,20 @@ class CodeCleaner(BaseModel, arbitrary_types_allowed=True):
     def remove_docstrings(self, code: str) -> str:
         lines = code.split("\n")
         cleaned_lines = []
-        in_docstring = False
-        docstring_delimiter = None
-        waiting_for_docstring = False
+        docstring_state = {"in_docstring": False, "delimiter": None, "waiting": False}
         for line in lines:
             stripped = line.strip()
-            if stripped.startswith(("def ", "class ", "async def ")):
-                waiting_for_docstring = True
+            if self._is_function_or_class_definition(stripped):
+                docstring_state["waiting"] = True
                 cleaned_lines.append(line)
                 continue
-            if waiting_for_docstring and stripped:
-                if stripped.startswith(('"""', "'''", '"', "'")):
-                    if stripped.startswith(('"""', "'''")):
-                        docstring_delimiter = stripped[:3]
-                    else:
-                        docstring_delimiter = stripped[0]
-                    if stripped.endswith(docstring_delimiter) and len(stripped) > len(
-                        docstring_delimiter
-                    ):
-                        waiting_for_docstring = False
-                        continue
-                    else:
-                        in_docstring = True
-                        waiting_for_docstring = False
-                        continue
+            if docstring_state["waiting"] and stripped:
+                if self._handle_docstring_start(stripped, docstring_state):
+                    continue
                 else:
-                    waiting_for_docstring = False
-            if in_docstring:
-                if docstring_delimiter and stripped.endswith(docstring_delimiter):
-                    in_docstring = False
-                    docstring_delimiter = None
+                    docstring_state["waiting"] = False
+            if docstring_state["in_docstring"]:
+                if self._handle_docstring_end(stripped, docstring_state):
                     continue
                 else:
                     continue
@@ -122,6 +105,35 @@ class CodeCleaner(BaseModel, arbitrary_types_allowed=True):
 
         return "\n".join(cleaned_lines)
 
+    def _is_function_or_class_definition(self, stripped_line: str) -> bool:
+        return stripped_line.startswith(("def ", "class ", "async def "))
+
+    def _handle_docstring_start(self, stripped: str, state: dict[str, t.Any]) -> bool:
+        if not stripped.startswith(('"""', "'''", '"', "'")):
+            return False
+        if stripped.startswith(('"""', "'''")):
+            delimiter = stripped[:3]
+        else:
+            delimiter = stripped[0]
+        state["delimiter"] = delimiter
+        if self._is_single_line_docstring(stripped, delimiter):
+            state["waiting"] = False
+            return True
+        else:
+            state["in_docstring"] = True
+            state["waiting"] = False
+            return True
+
+    def _is_single_line_docstring(self, stripped: str, delimiter: str) -> bool:
+        return stripped.endswith(delimiter) and len(stripped) > len(delimiter)
+
+    def _handle_docstring_end(self, stripped: str, state: dict[str, t.Any]) -> bool:
+        if state["delimiter"] and stripped.endswith(state["delimiter"]):
+            state["in_docstring"] = False
+            state["delimiter"] = None
+            return True
+        return True
+
     def remove_line_comments(self, code: str) -> str:
         lines = code.split("\n")
         cleaned_lines = []
@@ -129,87 +141,153 @@ class CodeCleaner(BaseModel, arbitrary_types_allowed=True):
             if not line.strip():
                 cleaned_lines.append(line)
                 continue
-            in_string = None
-            result = []
-            i = 0
-            n = len(line)
-            while i < n:
-                char = line[i]
-                if char in ("'", '"') and (i == 0 or line[i - 1] != "\\"):
-                    if in_string is None:
-                        in_string = char
-                    elif in_string == char:
-                        in_string = None
-                    result.append(char)
-                    i += 1
-                elif char == "#" and in_string is None:
-                    comment = line[i:].strip()
-                    if re.match(
-                        r"^#\s*(?:type:\s*ignore(?:\[.*?\])?|noqa|nosec|pragma:\s*no\s*cover|pylint:\s*disable|mypy:\s*ignore)",
-                        comment,
-                    ):
-                        result.append(line[i:])
-                        break
-                    break
-                else:
-                    result.append(char)
-                    i += 1
-            cleaned_line = "".join(result).rstrip()
+            cleaned_line = self._process_line_for_comments(line)
             if cleaned_line or not line.strip():
                 cleaned_lines.append(cleaned_line or line)
+
         return "\n".join(cleaned_lines)
 
+    def _process_line_for_comments(self, line: str) -> str:
+        result = []
+        string_state = {"in_string": None}
+        for i, char in enumerate(line):
+            if self._handle_string_character(char, i, line, string_state, result):
+                continue
+            elif self._handle_comment_character(char, i, line, string_state, result):
+                break
+            else:
+                result.append(char)
+
+        return "".join(result).rstrip()
+
+    def _handle_string_character(
+        self,
+        char: str,
+        index: int,
+        line: str,
+        string_state: dict[str, t.Any],
+        result: list[str],
+    ) -> bool:
+        """Handle string quote characters. Returns True if character was handled."""
+        if char not in ("'", '"'):
+            return False
+
+        if index > 0 and line[index - 1] == "\\":
+            return False
+
+        if string_state["in_string"] is None:
+            string_state["in_string"] = char
+        elif string_state["in_string"] == char:
+            string_state["in_string"] = None
+
+        result.append(char)
+        return True
+
+    def _handle_comment_character(
+        self,
+        char: str,
+        index: int,
+        line: str,
+        string_state: dict[str, t.Any],
+        result: list[str],
+    ) -> bool:
+        """Handle comment character. Returns True if comment was found."""
+        if char != "#" or string_state["in_string"] is not None:
+            return False
+
+        comment = line[index:].strip()
+        if self._is_special_comment_line(comment):
+            result.append(line[index:])
+
+        return True
+
+    def _is_special_comment_line(self, comment: str) -> bool:
+        special_comment_pattern = (
+            r"^#\s*(?:type:\s*ignore(?:\[.*?\])?|noqa|nosec|pragma:\s*no\s*cover"
+            r"|pylint:\s*disable|mypy:\s*ignore)"
+        )
+        return bool(re.match(special_comment_pattern, comment))
+
     def remove_extra_whitespace(self, code: str) -> str:
         lines = code.split("\n")
         cleaned_lines = []
-        in_function = False
-        function_indent = 0
+        function_tracker = {"in_function": False, "function_indent": 0}
         for i, line in enumerate(lines):
             line = line.rstrip()
             stripped_line = line.lstrip()
-            if stripped_line.startswith(("def ", "async def ")):
-                in_function = True
-                function_indent = len(line) - len(stripped_line)
-            elif (
-                in_function
-                and line
-                and (len(line) - len(stripped_line) <= function_indent)
-                and (not stripped_line.startswith(("@", "#")))
-            ):
-                in_function = False
-                function_indent = 0
+            self._update_function_state(line, stripped_line, function_tracker)
             if not line:
-                if i > 0 and cleaned_lines and (not cleaned_lines[-1]):
+                if self._should_skip_empty_line(
+                    i, lines, cleaned_lines, function_tracker
+                ):
                     continue
-                if in_function:
-                    next_line_idx = i + 1
-                    if next_line_idx < len(lines):
-                        next_line = lines[next_line_idx].strip()
-                        if not (
-                            next_line.startswith(
-                                ("return", "class ", "def ", "async def ", "@")
-                            )
-                            or next_line in ("pass", "break", "continue", "raise")
-                            or (
-                                next_line.startswith("#")
-                                and any(
-                                    pattern in next_line
-                                    for pattern in (
-                                        "type:",
-                                        "noqa",
-                                        "nosec",
-                                        "pragma:",
-                                        "pylint:",
-                                        "mypy:",
-                                    )
-                                )
-                            )
-                        ):
-                            continue
             cleaned_lines.append(line)
-        while cleaned_lines and (not cleaned_lines[-1]):
-            cleaned_lines.pop()
-        return "\n".join(cleaned_lines)
+
+        return "\n".join(self._remove_trailing_empty_lines(cleaned_lines))
+
+    def _update_function_state(
+        self, line: str, stripped_line: str, function_tracker: dict[str, t.Any]
+    ) -> None:
+        """Update function tracking state based on current line."""
+        if stripped_line.startswith(("def ", "async def ")):
+            function_tracker["in_function"] = True
+            function_tracker["function_indent"] = len(line) - len(stripped_line)
+        elif self._is_function_end(line, stripped_line, function_tracker):
+            function_tracker["in_function"] = False
+            function_tracker["function_indent"] = 0
+
+    def _is_function_end(
+        self, line: str, stripped_line: str, function_tracker: dict[str, t.Any]
+    ) -> bool:
+        """Check if current line marks the end of a function."""
+        return (
+            function_tracker["in_function"]
+            and bool(line)
+            and (len(line) - len(stripped_line) <= function_tracker["function_indent"])
+            and (not stripped_line.startswith(("@", "#")))
+        )
+
+    def _should_skip_empty_line(
+        self,
+        line_idx: int,
+        lines: list[str],
+        cleaned_lines: list[str],
+        function_tracker: dict[str, t.Any],
+    ) -> bool:
+        """Determine if an empty line should be skipped."""
+        if line_idx > 0 and cleaned_lines and (not cleaned_lines[-1]):
+            return True
+
+        if function_tracker["in_function"]:
+            return self._should_skip_function_empty_line(line_idx, lines)
+
+        return False
+
+    def _should_skip_function_empty_line(self, line_idx: int, lines: list[str]) -> bool:
+        next_line_idx = line_idx + 1
+        if next_line_idx >= len(lines):
+            return False
+        next_line = lines[next_line_idx].strip()
+        return not self._is_significant_next_line(next_line)
+
+    def _is_significant_next_line(self, next_line: str) -> bool:
+        if next_line.startswith(("return", "class ", "def ", "async def ", "@")):
+            return True
+        if next_line in ("pass", "break", "continue", "raise"):
+            return True
+
+        return self._is_special_comment(next_line)
+
+    def _is_special_comment(self, line: str) -> bool:
+        if not line.startswith("#"):
+            return False
+        special_patterns = ("type:", "noqa", "nosec", "pragma:", "pylint:", "mypy:")
+        return any(pattern in line for pattern in special_patterns)
+
+    def _remove_trailing_empty_lines(self, lines: list[str]) -> list[str]:
+        while lines and (not lines[-1]):
+            lines.pop()
+        return lines
 
     def reformat_code(self, code: str) -> str:
         from crackerjack.errors import handle_error
@@ -335,27 +413,75 @@ class ConfigManager(BaseModel, arbitrary_types_allowed=True):
         self, our_toml_config: dict[str, t.Any], pkg_toml_config: dict[str, t.Any]
     ) -> None:
         for tool, settings in our_toml_config.get("tool", {}).items():
-            for setting, value in settings.items():
-                if isinstance(value, dict):
-                    for k, v in {
-                        x: self.swap_package_name(y)
-                        for x, y in value.items()
-                        if isinstance(y, str | list) and "crackerjack" in str(y)
-                    }.items():
-                        settings[setting][k] = v
-                elif isinstance(value, str | list) and "crackerjack" in str(value):
-                    value = self.swap_package_name(value)
-                    settings[setting] = value
-                if setting in (
-                    "exclude-deps",
-                    "exclude",
-                    "excluded",
-                    "skips",
-                    "ignore",
-                ) and isinstance(value, list):
-                    conf = pkg_toml_config["tool"].get(tool, {}).get(setting, [])
-                    settings[setting] = list(set(conf + value))
-            pkg_toml_config["tool"][tool] = settings
+            if tool not in pkg_toml_config["tool"]:
+                pkg_toml_config["tool"][tool] = {}
+
+            pkg_tool_config = pkg_toml_config["tool"][tool]
+
+            self._merge_tool_config(settings, pkg_tool_config, tool)
+
+    def _merge_tool_config(
+        self, our_config: dict[str, t.Any], pkg_config: dict[str, t.Any], tool: str
+    ) -> None:
+        """Recursively merge tool configuration, preserving existing project settings."""
+        for setting, value in our_config.items():
+            if isinstance(value, dict):
+                self._merge_nested_config(setting, value, pkg_config)
+            else:
+                self._merge_direct_config(setting, value, pkg_config)
+
+    def _merge_nested_config(
+        self, setting: str, value: dict[str, t.Any], pkg_config: dict[str, t.Any]
+    ) -> None:
+        """Handle nested configuration merging."""
+        if setting not in pkg_config:
+            pkg_config[setting] = {}
+        elif not isinstance(pkg_config[setting], dict):
+            pkg_config[setting] = {}
+
+        self._merge_tool_config(value, pkg_config[setting], "")
+
+        for k, v in value.items():
+            self._merge_nested_value(k, v, pkg_config[setting])
+
+    def _merge_nested_value(
+        self, key: str, value: t.Any, nested_config: dict[str, t.Any]
+    ) -> None:
+        """Merge individual nested values."""
+        if isinstance(value, str | list) and "crackerjack" in str(value):
+            nested_config[key] = self.swap_package_name(value)
+        elif self._is_mergeable_list(key, value):
+            existing = nested_config.get(key, [])
+            if isinstance(existing, list) and isinstance(value, list):
+                nested_config[key] = list(set(existing + value))
+            else:
+                nested_config[key] = value
+        elif key not in nested_config:
+            nested_config[key] = value
+
+    def _merge_direct_config(
+        self, setting: str, value: t.Any, pkg_config: dict[str, t.Any]
+    ) -> None:
+        """Handle direct configuration merging."""
+        if isinstance(value, str | list) and "crackerjack" in str(value):
+            pkg_config[setting] = self.swap_package_name(value)
+        elif self._is_mergeable_list(setting, value):
+            existing = pkg_config.get(setting, [])
+            if isinstance(existing, list) and isinstance(value, list):
+                pkg_config[setting] = list(set(existing + value))
+            else:
+                pkg_config[setting] = value
+        elif setting not in pkg_config:
+            pkg_config[setting] = value
+
+    def _is_mergeable_list(self, key: str, value: t.Any) -> bool:
+        return key in (
+            "exclude-deps",
+            "exclude",
+            "excluded",
+            "skips",
+            "ignore",
+        ) and isinstance(value, list)
 
     def _update_python_version(
         self, our_toml_config: dict[str, t.Any], pkg_toml_config: dict[str, t.Any]
@@ -520,11 +646,6 @@ class Crackerjack(BaseModel, arbitrary_types_allowed=True):
         if self.pkg_path.stem == "crackerjack" and options.update_precommit:
             self.execute_command(["pre-commit", "autoupdate"])
 
-    def _run_interactive_hooks(self, options: t.Any) -> None:
-        if options.interactive:
-            for hook in interactive_hooks:
-                self.project_manager.run_interactive(hook)
-
     def _clean_project(self, options: t.Any) -> None:
         if options.clean:
             if self.pkg_dir:
@@ -655,7 +776,6 @@ class Crackerjack(BaseModel, arbitrary_types_allowed=True):
         self._setup_package()
         self._update_project(options)
         self._update_precommit(options)
-        self._run_interactive_hooks(options)
         self._clean_project(options)
         if not options.skip_hooks:
             self.project_manager.run_pre_commit()

crackerjack/interactive.py

@@ -260,11 +260,26 @@ class InteractiveCLI:
 
     def run_interactive(self) -> None:
         self.console.clear()
+        layout = self._setup_interactive_layout()
+        progress_tracker = self._create_progress_tracker()
+        with Live(layout, refresh_per_second=4, screen=True) as live:
+            try:
+                self._execute_workflow_loop(layout, progress_tracker, live)
+                self._display_final_summary(layout)
+            except KeyboardInterrupt:
+                self._handle_user_interruption(layout)
+        self.console.print("\nWorkflow Status:")
+        self.workflow.display_task_tree()
+
+    def _setup_interactive_layout(self) -> Layout:
         layout = self.setup_layout()
         layout["header"].update(
             Panel("Crackerjack Interactive Mode", style="bold cyan", box=ROUNDED)
         )
         layout["footer"].update(Panel("Press Ctrl+C to exit", style="dim", box=ROUNDED))
+        return layout
+
+    def _create_progress_tracker(self) -> dict[str, t.Any]:
         progress = Progress(
             SpinnerColumn(),
             TextColumn("[bold blue]{task.description}"),
@@ -274,72 +289,110 @@ class InteractiveCLI:
         )
         total_tasks = len(self.workflow.tasks)
         progress_task = progress.add_task("Running workflow", total=total_tasks)
-        completed_tasks = 0
-        with Live(layout, refresh_per_second=4, screen=True) as live:
-            try:
-                while not self.workflow.all_tasks_completed():
-                    layout["tasks"].update(self.show_task_table())
-                    next_task = self.workflow.get_next_task()
-                    if not next_task:
-                        break
-                    layout["details"].update(self.show_task_status(next_task))
-                    live.stop()
-                    should_run = Confirm.ask(
-                        f"Run task '{next_task.name}'?", default=True
-                    )
-                    live.start()
-                    if not should_run:
-                        next_task.skip()
-                        continue
-                    next_task.start()
-                    layout["details"].update(self.show_task_status(next_task))
-                    time.sleep(1)
-                    import random
-
-                    success = random.choice([True, True, True, False])
-                    if success:
-                        next_task.complete(True)
-                        completed_tasks += 1
-                    else:
-                        from .errors import ExecutionError
-
-                        error = ExecutionError(
-                            message=f"Task '{next_task.name}' failed",
-                            error_code=ErrorCode.COMMAND_EXECUTION_ERROR,
-                            details="This is a simulated failure for demonstration.",
-                            recovery=f"Retry the '{next_task.name}' task.",
-                        )
-                        next_task.fail(error)
-                    progress.update(progress_task, completed=completed_tasks)
-                    layout["details"].update(self.show_task_status(next_task))
-                layout["tasks"].update(self.show_task_table())
-                successful = sum(
-                    1
-                    for task in self.workflow.tasks.values()
-                    if task.status == TaskStatus.SUCCESS
-                )
-                failed = sum(
-                    1
-                    for task in self.workflow.tasks.values()
-                    if task.status == TaskStatus.FAILED
-                )
-                skipped = sum(
-                    1
-                    for task in self.workflow.tasks.values()
-                    if task.status == TaskStatus.SKIPPED
-                )
-                summary = Panel(
-                    f"Workflow completed!\n\n[green]✅ Successful tasks: {successful}[/green]\n[red]❌ Failed tasks: {failed}[/red]\n[blue]⏩ Skipped tasks: {skipped}[/blue]",
-                    title="Summary",
-                    border_style="cyan",
-                )
-                layout["details"].update(summary)
-            except KeyboardInterrupt:
-                layout["footer"].update(
-                    Panel("Interrupted by user", style="yellow", box=ROUNDED)
-                )
-        self.console.print("\nWorkflow Status:")
-        self.workflow.display_task_tree()
+
+        return {
+            "progress": progress,
+            "progress_task": progress_task,
+            "completed_tasks": 0,
+        }
+
+    def _execute_workflow_loop(
+        self, layout: Layout, progress_tracker: dict[str, t.Any], live: Live
+    ) -> None:
+        """Execute the main workflow loop."""
+        while not self.workflow.all_tasks_completed():
+            layout["tasks"].update(self.show_task_table())
+            next_task = self.workflow.get_next_task()
+
+            if not next_task:
+                break
+
+            if self._should_execute_task(layout, next_task, live):
+                self._execute_task(layout, next_task, progress_tracker)
+            else:
+                next_task.skip()
+
+    def _should_execute_task(self, layout: Layout, task: Task, live: Live) -> bool:
+        layout["details"].update(self.show_task_status(task))
+        live.stop()
+        should_run = Confirm.ask(f"Run task '{task.name}'?", default=True)
+        live.start()
+        return should_run
+
+    def _execute_task(
+        self, layout: Layout, task: Task, progress_tracker: dict[str, t.Any]
+    ) -> None:
+        """Execute a single task and update progress."""
+        task.start()
+        layout["details"].update(self.show_task_status(task))
+        time.sleep(1)
+
+        success = self._simulate_task_execution()
+
+        if success:
+            task.complete()
+            progress_tracker["completed_tasks"] += 1
+        else:
+            error = self._create_task_error(task.name)
+            task.fail(error)
+
+        progress_tracker["progress"].update(
+            progress_tracker["progress_task"],
+            completed=progress_tracker["completed_tasks"],
+        )
+        layout["details"].update(self.show_task_status(task))
+
+    def _simulate_task_execution(self) -> bool:
+        import random
+
+        return random.choice([True, True, True, False])
+
+    def _create_task_error(self, task_name: str) -> t.Any:
+        from .errors import ExecutionError
+
+        return ExecutionError(
+            message=f"Task '{task_name}' failed",
+            error_code=ErrorCode.COMMAND_EXECUTION_ERROR,
+            details="This is a simulated failure for demonstration.",
+            recovery=f"Retry the '{task_name}' task.",
+        )
+
+    def _display_final_summary(self, layout: Layout) -> None:
+        layout["tasks"].update(self.show_task_table())
+        task_counts = self._count_tasks_by_status()
+        summary = Panel(
+            f"Workflow completed!\n\n"
+            f"[green]✅ Successful tasks: {task_counts['successful']}[/green]\n"
+            f"[red]❌ Failed tasks: {task_counts['failed']}[/red]\n"
+            f"[blue]⏩ Skipped tasks: {task_counts['skipped']}[/blue]",
+            title="Summary",
+            border_style="cyan",
+        )
+        layout["details"].update(summary)
+
+    def _count_tasks_by_status(self) -> dict[str, int]:
+        return {
+            "successful": sum(
+                1
+                for task in self.workflow.tasks.values()
+                if task.status == TaskStatus.SUCCESS
+            ),
+            "failed": sum(
+                1
+                for task in self.workflow.tasks.values()
+                if task.status == TaskStatus.FAILED
+            ),
+            "skipped": sum(
+                1
+                for task in self.workflow.tasks.values()
+                if task.status == TaskStatus.SKIPPED
+            ),
+        }
+
+    def _handle_user_interruption(self, layout: Layout) -> None:
+        layout["footer"].update(
+            Panel("Interrupted by user", style="yellow", box=ROUNDED)
+        )
 
     def ask_for_file(
         self, prompt: str, directory: Path, default: str | None = None

crackerjack/pyproject.toml

@@ -4,7 +4,7 @@ requires = [ "pdm-backend" ]
 
 [project]
 name = "crackerjack"
-version = "0.20.19"
+version = "0.20.20"
 description = "Crackerjack: code quality toolkit"
 readme = "README.md"
 keywords = [
@@ -43,11 +43,11 @@ classifiers = [
 dependencies = [
     "autotyping>=24.9",
     "keyring>=25.6",
-    "pdm>=2.25.2",
+    "pdm>=2.25.3",
     "pdm-bump>=0.9.12",
     "pre-commit>=4.2",
     "pydantic>=2.11.7",
-    "pytest>=8.4",
+    "pytest>=8.4.1",
     "pytest-asyncio>=1",
     "pytest-benchmark>=5.1",
     "pytest-cov>=6.2.1",
@@ -58,7 +58,7 @@ dependencies = [
     "rich>=14",
     "tomli-w>=1.2",
     "typer>=0.16",
-    "uv>=0.7.13",
+    "uv>=0.7.15",
 ]
 urls.documentation = "https://github.com/lesleslie/crackerjack"
 urls.homepage = "https://github.com/lesleslie/crackerjack"
@@ -89,6 +89,7 @@ lint.ignore = [
     "D105",
     "D106",
     "D107",
+    "E402",
     "F821",
     "UP040",
 ]
@@ -221,6 +222,8 @@ exclude-deps = [
     "google-crc32c",
     "pytest-timeout",
     "keyring",
+    "inflection",
+    "pydantic-settings",
 ]
 
 [tool.refurb]

{crackerjack-0.20.20.dist-info → crackerjack-0.21.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: crackerjack
-Version: 0.20.20
+Version: 0.21.0
 Summary: Crackerjack: code quality toolkit
 Keywords: bandit,black,creosote,mypy,pyright,pytest,refurb,ruff
 Author-Email: lesleslie <les@wedgwoodwebworks.com>
@@ -24,11 +24,11 @@ Project-URL: repository, https://github.com/lesleslie/crackerjack
 Requires-Python: >=3.13
 Requires-Dist: autotyping>=24.9
 Requires-Dist: keyring>=25.6
-Requires-Dist: pdm>=2.25.2
+Requires-Dist: pdm>=2.25.3
 Requires-Dist: pdm-bump>=0.9.12
 Requires-Dist: pre-commit>=4.2
 Requires-Dist: pydantic>=2.11.7
-Requires-Dist: pytest>=8.4
+Requires-Dist: pytest>=8.4.1
 Requires-Dist: pytest-asyncio>=1
 Requires-Dist: pytest-benchmark>=5.1
 Requires-Dist: pytest-cov>=6.2.1
@@ -39,7 +39,7 @@ Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: rich>=14
 Requires-Dist: tomli-w>=1.2
 Requires-Dist: typer>=0.16
-Requires-Dist: uv>=0.7.13
+Requires-Dist: uv>=0.7.15
 Description-Content-Type: text/markdown
 
 # Crackerjack: Elevate Your Python Development

{crackerjack-0.20.20.dist-info → crackerjack-0.21.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
-crackerjack-0.20.20.dist-info/METADATA,sha256=ZgwCSjG9EFBVIxNHdfz00rPm2J7CQTLkO1Tdui7w_P0,26413
-crackerjack-0.20.20.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
-crackerjack-0.20.20.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
-crackerjack-0.20.20.dist-info/licenses/LICENSE,sha256=fDt371P6_6sCu7RyqiZH_AhT1LdN3sN1zjBtqEhDYCk,1531
+crackerjack-0.21.0.dist-info/METADATA,sha256=5sb-8guKpbw-RU1VKg-VttPLTQTefNrvlNhQgEW3kTc,26414
+crackerjack-0.21.0.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
+crackerjack-0.21.0.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+crackerjack-0.21.0.dist-info/licenses/LICENSE,sha256=fDt371P6_6sCu7RyqiZH_AhT1LdN3sN1zjBtqEhDYCk,1531
 crackerjack/.gitignore,sha256=FOLrDV-tuHpwof310aOi6cWOkJXeVI_gvWvg_paDzs4,199
 crackerjack/.libcst.codemod.yaml,sha256=a8DlErRAIPV1nE6QlyXPAzTOgkB24_spl2E9hphuf5s,772
 crackerjack/.pdm.toml,sha256=dZe44HRcuxxCFESGG8SZIjmc-cGzSoyK3Hs6t4NYA8w,23
-crackerjack/.pre-commit-config.yaml,sha256=RwXcH8uvF8-mvappcz_oUFB5GsRq-Z4fQ7OcCR1oLWU,2935
+crackerjack/.pre-commit-config.yaml,sha256=glBcQ4nwC28t4Ier2E69bUg8pNQ9YyCtHmD-fV6bRm0,3076
 crackerjack/.pytest_cache/.gitignore,sha256=Ptcxtl0GFQwTji2tsL4Gl1UIiKa0frjEXsya26i46b0,37
 crackerjack/.pytest_cache/CACHEDIR.TAG,sha256=N9yI75oKvt2-gQU6bdj9-xOvthMEXqHrSlyBWnSjveQ,191
 crackerjack/.pytest_cache/README.md,sha256=c_1vzN2ALEGaay2YPWwxc7fal1WKxLWJ7ewt_kQ9ua0,302
@@ -32,6 +32,8 @@ crackerjack/.ruff_cache/0.11.6/3557596832929915217,sha256=yR2iXWDkSHVRw2eTiaCE8E
 crackerjack/.ruff_cache/0.11.7/10386934055395314831,sha256=lBNwN5zAgM4OzbkXIOzCczUtfooATrD10htj9ASlFkc,224
 crackerjack/.ruff_cache/0.11.7/3557596832929915217,sha256=fKlwUbsvT3YIKV6UR-aA_i64lLignWeVfVu-MMmVbU0,207
 crackerjack/.ruff_cache/0.11.8/530407680854991027,sha256=xAMAL3Vu_HR6M-h5ojCTaak0By5ii8u-14pXULLgLqw,224
+crackerjack/.ruff_cache/0.12.0/5056746222905752453,sha256=MqrIT5qymJcgAOBZyn-TvYoGCFfDFCgN9IwSULq8n14,256
+crackerjack/.ruff_cache/0.12.1/5056746222905752453,sha256=DxPQ70wEGAhDamfTzZgdH_n7fxBhsV_59f3jApsFXu0,256
 crackerjack/.ruff_cache/0.2.0/10047773857155985907,sha256=j9LNa_RQ4Plor7go1uTYgz17cEENKvZQ-dP6b9MX0ik,248
 crackerjack/.ruff_cache/0.2.1/8522267973936635051,sha256=u_aPBMibtAp_iYvLwR88GMAECMcIgHezxMyuapmU2P4,248
 crackerjack/.ruff_cache/0.2.2/18053836298936336950,sha256=Xb_ebP0pVuUfSqPEZKlhQ70so_vqkEfMYpuHQ06iR5U,248
@@ -60,10 +62,10 @@ crackerjack/.ruff_cache/0.9.9/12813592349865671909,sha256=tmr8_vhRD2OxsVuMfbJPdT
 crackerjack/.ruff_cache/0.9.9/8843823720003377982,sha256=e4ymkXfQsUg5e_mtO34xTsaTvs1uA3_fI216Qq9qCAM,136
 crackerjack/.ruff_cache/CACHEDIR.TAG,sha256=WVMVbX4MVkpCclExbq8m-IcOZIOuIZf5FrYw5Pk-Ma4,43
 crackerjack/__init__.py,sha256=8tBSPAru_YDuPpjz05cL7pNbZjYFoRT_agGd_FWa3gY,839
-crackerjack/__main__.py,sha256=A_qOog8kowRG3Z65pG11MK25t3n7eGdEldQNELurwJk,6734
-crackerjack/crackerjack.py,sha256=seIDpPlq6Kq_rzQh5ext-VCNhDIPfhIrfyaucGfCACQ,26882
+crackerjack/__main__.py,sha256=AknITUlFjq3YUK9s2xeL62dM0GN82JBQyDkPzQ_hCUg,6561
+crackerjack/crackerjack.py,sha256=pENFT19EqA4DBro9YtmP8avhfQbPljMkRF5MXn0eybo,30900
 crackerjack/errors.py,sha256=QEPtVuMtKtQHuawgr1ToMaN1KbUg5h9-4mS33YB5Znk,4062
-crackerjack/interactive.py,sha256=gP2Mb7jjBfR6RIlCUXh77_M-an5OXfTVXfUmnN-9ggA,15076
+crackerjack/interactive.py,sha256=5KXKSvWKttLvHcI1L4VEDc3Rb-ZpHBOl_Qr7lhD-O4Q,16262
 crackerjack/py313.py,sha256=buYE7LO11Q64ffowEhTZRFQoAGj_8sg3DTlZuv8M9eo,5890
-crackerjack/pyproject.toml,sha256=9KWpTTwX6z2nDhZChQL6xIGuCnKGnCIikZlqvfDtmYs,4932
-crackerjack-0.20.20.dist-info/RECORD,,
+crackerjack/pyproject.toml,sha256=kiN_CuXFS307ca2CvLt-nDvZbFgouTxb1uIsSEkdIDk,4989
+crackerjack-0.21.0.dist-info/RECORD,,