Conversation
Reviewer's GuideThis PR introduces a new --verbose flag that is parsed from the CLI, propagated through render_block, check_file, and main functions, and conditionally prints each mermaid-cli invocation; it also updates documentation and adds comprehensive tests to verify verbose behavior and flag propagation. Sequence diagram for --verbose flag propagation and command printingsequenceDiagram
actor User
participant CLI as cli()
participant Args as parse_args()
participant Main as main()
participant Check as check_file()
participant Render as render_block()
User->>CLI: Run nixie --verbose FILE
CLI->>Args: parse_args()
Args-->>CLI: Namespace with verbose=True
CLI->>Main: main(paths, concurrency, verbose=True)
Main->>Check: check_file(path, cfg_path, semaphore, verbose=True)
Check->>Render: render_block(..., verbose=True)
Render->>Render: print(shlex.join(cmd)) if verbose
Class diagram for CLI argument propagation with --verbose flagclassDiagram
class CLI {
+cli()
}
class parse_args {
+parse_args() : argparse.Namespace
}
class main {
+main(paths, max_concurrent, verbose=False)
}
class check_file {
+check_file(path, cfg_path, semaphore, verbose=False)
}
class render_block {
+render_block(block, tmpdir, cfg_path, path, idx, semaphore, timeout=30.0, verbose=False)
}
CLI --> parse_args : calls
CLI --> main : calls
parse_args --> main : passes parsed.verbose
main --> check_file : passes verbose
check_file --> render_block : passes verbose
File-Level Changes
Tips and commandsInteracting with Sourcery
Customizing Your ExperienceAccess your dashboard to:
Getting Help
|
|
Note Other AI code review bot(s) detectedCodeRabbit has detected other AI code review bot(s) in this pull request and will avoid duplicating their findings in the review comments. This may lead to a less comprehensive review. Summary by CodeRabbit
WalkthroughUpdate the Changes
Sequence Diagram(s)sequenceDiagram
participant User
participant CLI
participant Logger
participant MermaidCLI
User->>CLI: Run nixie [--verbose] [--concurrency N] <files>
CLI->>CLI: Parse arguments
alt --verbose flag set
CLI->>Logger: Set level to INFO
else
CLI->>Logger: Set level to WARNING
end
CLI->>MermaidCLI: Build command
alt --verbose flag set
CLI->>Logger: Log executed command (INFO)
end
CLI->>MermaidCLI: Execute command
Estimated code review effort🎯 2 (Simple) | ⏱️ ~7 minutes Possibly related PRs
Poem
📜 Recent review detailsConfiguration used: CodeRabbit UI 📒 Files selected for processing (1)
🧰 Additional context used📓 Path-based instructions (1)**/*.py📄 CodeRabbit Inference Engine (AGENTS.md)
Files:
⚙️ CodeRabbit Configuration File
Files:
🔇 Additional comments (7)
✨ Finishing Touches
🧪 Generate unit tests
🪧 TipsChatThere are 3 ways to chat with CodeRabbit:
SupportNeed help? Create a ticket on our support page for assistance with any issues or questions. CodeRabbit Commands (Invoked using PR comments)
Other keywords and placeholders
CodeRabbit Configuration File (
|
![sourcery-ai[bot]](https://avatars.githubusercontent.com/in/48477?s=60&v=4){kind=small}
There was a problem hiding this comment.
Hey @leynos - I've reviewed your changes and found some issues that need to be addressed.
- Rather than sprinkling print statements for verbose output, consider using the Python logging module at a DEBUG or INFO level so users can configure verbosity without mixing it into functional stdout.
- The
verboseflag is being threaded throughmain,check_file, andrender_block; you might simplify this by encapsulating CLI options in a context or class to avoid changing every function signature. - Since verbose info is primarily diagnostic, it would be better sent to stderr instead of stdout, preventing it from interfering with normal CLI output or piping scenarios.
Prompt for AI Agents
Please address the comments from this code review:
## Overall Comments
- Rather than sprinkling print statements for verbose output, consider using the Python logging module at a DEBUG or INFO level so users can configure verbosity without mixing it into functional stdout.
- The `verbose` flag is being threaded through `main`, `check_file`, and `render_block`; you might simplify this by encapsulating CLI options in a context or class to avoid changing every function signature.
- Since verbose info is primarily diagnostic, it would be better sent to stderr instead of stdout, preventing it from interfering with normal CLI output or piping scenarios.
## Individual Comments
### Comment 1
<location> `nixie/cli.py:116` </location>
<code_context>
idx: int,
semaphore: asyncio.Semaphore,
timeout: float = 30.0,
+ verbose: bool = False,
) -> bool:
"""Render a single mermaid block using the CLI asynchronously."""
</code_context>
<issue_to_address>
Consider documenting the new 'verbose' parameter in the function docstring.
Adding this detail will make the function's usage clearer for future maintainers.
</issue_to_address>
<suggested_fix>
<<<<<<< SEARCH
) -> bool:
"""Render a single mermaid block using the CLI asynchronously."""
=======
) -> bool:
"""
Render a single mermaid block using the CLI asynchronously.
Args:
idx (int): Index of the block.
semaphore (asyncio.Semaphore): Semaphore to limit concurrency.
timeout (float, optional): Timeout for the operation. Defaults to 30.0.
verbose (bool, optional): If True, prints the CLI command being executed. Defaults to False.
"""
>>>>>>> REPLACE
</suggested_fix>
### Comment 2
<location> `nixie/unittests/test_verbose.py:21` </location>
<code_context>
assert "Simulated processing error" in captured.out
+
+
+@pytest.mark.asyncio
+async def test_cli_passes_verbose_flag(tmp_path: Path, stub_render: AsyncMock) -> None:
+ file_a = tmp_path / "a.md"
+ file_a.write_text("```mermaid\nA-->B\n```")
+
+ await main([file_a], 2, verbose=True)
+
+ assert stub_render.await_count == 1
+ assert stub_render.await_args_list[0].kwargs["verbose"] is True
</code_context>
<issue_to_address>
Test for render_block with verbose covers output, but could use an error case.
Consider adding a test for when verbose is False to ensure no command output is printed, preventing unintended verbose output in the future.
</issue_to_address>Help me be more useful! Please click 👍 or 👎 on each comment and I'll use the feedback to improve your reviews.
nixie/cli.py
Outdated
| ) -> bool: | ||
| """Render a single mermaid block using the CLI asynchronously.""" |
There was a problem hiding this comment.
suggestion: Consider documenting the new 'verbose' parameter in the function docstring.
Adding this detail will make the function's usage clearer for future maintainers.
| ) -> bool: | |
| """Render a single mermaid block using the CLI asynchronously.""" | |
| ) -> bool: | |
| """ | |
| Render a single mermaid block using the CLI asynchronously. | |
| Args: | |
| idx (int): Index of the block. | |
| semaphore (asyncio.Semaphore): Semaphore to limit concurrency. | |
| timeout (float, optional): Timeout for the operation. Defaults to 30.0. | |
| verbose (bool, optional): If True, prints the CLI command being executed. Defaults to False. | |
| """ |
There was a problem hiding this comment.
Has this now been resolved?
There was a problem hiding this comment.
It looks like the suggestion to document the 'verbose' parameter in the render_block function's docstring has not yet been addressed. The current docstring does not mention the 'verbose' parameter or its purpose. To fully resolve the suggestion, please update the docstring to include a description of the 'verbose' argument and its effect on the function's behavior.
There was a problem hiding this comment.
Has this now been resolved?
There was a problem hiding this comment.
The suggestion to document the 'verbose' parameter in the render_block function's docstring has not yet been resolved. In the current state of the PR, while the verbose parameter is being added to the function signature, the docstring does not mention this new parameter or its effect. To fully address the suggestion, please update the docstring for render_block to include a description of the verbose argument and how it influences the function's behavior (e.g., printing/logging the CLI command when enabled).
![coderabbitai[bot]](https://avatars.githubusercontent.com/in/347564?s=60&v=4){kind=small}
There was a problem hiding this comment.
Actionable comments posted: 3
♻️ Duplicate comments (1)
nixie/cli.py (1)
109-117: Add documentation for the verbose functionality.The function signature is missing documentation for how the verbose logging behaviour is controlled, which was previously suggested in a past review.
Add the verbose parameter documentation to the docstring:
async def render_block( block: str, tmpdir: Path, cfg_path: Path, path: Path, idx: int, semaphore: asyncio.Semaphore, timeout: float = 30.0, ) -> bool: - """Render a single mermaid block using the CLI asynchronously.""" + """ + Render a single mermaid block using the CLI asynchronously. + + Logs the exact mermaid-cli command at INFO level when verbose logging is enabled. + """
📜 Review details
Configuration used: CodeRabbit UI
Review profile: ASSERTIVE
Plan: Pro
📒 Files selected for processing (3)
README.md(1 hunks)nixie/cli.py(6 hunks)nixie/unittests/test_verbose.py(1 hunks)
🧰 Additional context used
📓 Path-based instructions (5)
**/*.md
📄 CodeRabbit Inference Engine (AGENTS.md)
For Markdown files (
.mdonly): Pass lint checks (markdownlint filename.md).
Files:
README.md
⚙️ CodeRabbit Configuration File
**/*.md: * Avoid 2nd person or 1st person pronouns ("I", "you", "we")
- Use en-GB-oxendict (-ize / -our) spelling and grammar
- Paragraphs and bullets must be wrapped to 80 columns, except where a long URL would prevent this (in which case, silence MD013 for that line)
- Code blocks should be wrapped to 120 columns.
- Headings must not be wrapped.
- Documents must start with a level 1 heading
- Headings must correctly increase or decrease by no more than one level at a time
- Use GitHub-flavoured Markdown style for footnotes and endnotes.
- Numbered footnotes must be numbered by order of appearance in the document.
Files:
README.md
{**/README.md,**/docs/**}
📄 CodeRabbit Inference Engine (.rules/python-00.mdc)
Colocate documentation by keeping README.md or docs/ near reusable packages and include usage examples
Files:
README.md
**/*.py
📄 CodeRabbit Inference Engine (AGENTS.md)
For Python files: Pass all relevant unit and behavioral tests, pass lint checks (
ruff check), adhere to formatting standards (ruff format), and pass type checking (pyright).
**/*.py: Use snake_case.py for file names, naming files for their contents (e.g., http_client.py, task_queue.py)
Use PascalCase for class names in Python files
Use snake_case for variable and function names in Python files
Use UPPER_SNAKE_CASE for module-level constants in Python files
Prefix private/internal helpers or APIs with a single underscore (_) in Python files
Use typing everywhere and maintain full static type coverage in Python files; use Pyright for type-checking
Use TypedDict or Dataclass for structured data where appropriate; for internal-only usage, prefer @DataClass(slots=True)
Avoid Any in type annotations; use Unknown, generics, or cast() when necessary, and always document why Any is acceptable if used
Be explicit with return types in public functions and class methods (e.g., use -> None, -> str, etc.)
Favor immutability in Python files; prefer tuples over lists, and frozendict or types.MappingProxyType where appropriate
Enable Ruff for linting and formatting; use Ruff to lint for performance, security, consistency, and style issues, and let Ruff handle whitespace and formatting entirely
Enforce strict mode in Pyright and treat all Pyright warnings as CI errors; use # pyright: ignore sparingly and with explanation
Avoid side effects at import time in Python modules; modules should not modify global state or perform actions on import
Use docstrings to document public functions, classes, and modules using NumPy format
Explain tricky code with inline comments for non-obvious logic or decisions in Python files
**/*.py: Use context managers to encapsulate setup and teardown logic cleanly and safely, especially for resource management (files, locks, connections, etc.), instead of manual try/finally blocks.
Use@contextmanagerfromcontextlibfor straightforward proce...
Files:
nixie/cli.pynixie/unittests/test_verbose.py
⚙️ CodeRabbit Configuration File
**/*.py: How about the following?- Keep cyclomatic complexity ≤ 12 - Follow single responsibility and CQRS (command/query segregation) - Docstrings must follow the `numpy` style guide. Use a single-line summary for private functions and methods, and full structured docs for all public interfaces. - Move conditionals with >2 branches to predicate/helper functions - Avoid `eval`, `exec`, `pickle`, monkey-patching, `ctypes`, unsafe shell - Every module must begin with a triple-quoted docstring explaining its purpose, utility, and usage, including example calls if appropriate. - Comments and docs must follow en-GB-oxendict (-ize / -our) spelling and grammar - Lint suppressions: - Blanket `# noqa`, file-level skips, and categories are **forbidden** - Only narrow in-line disables (`# noqa: XYZ`) are permitted, and must be accompanied by `FIXME:` or a ticket link, and used only as a last resort. - Use `pytest` fixtures for shared setup (`conftest.py` or `fixtures/`) - Replace duplicate tests with `@pytest.mark.parametrize` - Prefer `pytest-mock` or `unittest.mock` for stubs/mocks - Use `assert …, "message"` over bare asserts - Reflect all API/behaviour changes in `docs/` and update roadmap on completion - Files must not exceed 400 logical lines: - Decompose large modules into subpackages - Split large `match/case` or dispatch tables by domain and collocate with targets if appropriate - Move bulky data (fixtures, templates) to external files for parsing at runtime - Mutable defaults and shadowed built-ins are forbidden - All code must have clear type hints using modern style (`A | B`, `list[str]`, `class Foo[A]:`, `type Bar = int`, etc.), with ABC imports drawn from the correct stdlib module.
Files:
nixie/cli.pynixie/unittests/test_verbose.py
**/unittests/test_*.py
📄 CodeRabbit Inference Engine (.rules/python-00.mdc)
Colocate unit tests with code using a unittests subdirectory and a test_ prefix for test files
Files:
nixie/unittests/test_verbose.py
**/test_*.py
📄 CodeRabbit Inference Engine (.rules/python-00.mdc)
**/test_*.py: Use pytest idioms in test files: prefer fixtures over setup/teardown methods, parametrize broadly, and avoid unnecessary mocks
Group related tests using class with method names prefixed by test_ in test files
Files:
nixie/unittests/test_verbose.py
🪛 Ruff (0.12.2)
nixie/unittests/test_verbose.py
15-15: Missing type annotation for function argument monkeypatch
(ANN001)
24-24: Missing type annotation for function argument monkeypatch
(ANN001)
24-24: Trailing comma missing
Add trailing comma
(COM812)
31-31: Missing return type annotation for private function fake_create_subprocess_exec
(ANN202)
31-31: Missing type annotation for *cmd
(ANN002)
31-31: Unused function argument: cmd
(ARG001)
31-31: Missing type annotation for **kwargs
(ANN003)
31-31: Unused function argument: kwargs
(ARG001)
34-34: Missing return type annotation for private function fake_wait_for_proc
(ANN202)
34-34: Missing type annotation for function argument proc
(ANN001)
34-34: Unused function argument: proc
(ARG001)
34-34: Missing type annotation for function argument path
(ANN001)
34-34: Unused function argument: path
(ARG001)
34-34: Missing type annotation for function argument idx
(ANN001)
34-34: Unused function argument: idx
(ARG001)
34-34: Async function definition with a timeout parameter
(ASYNC109)
34-34: Missing type annotation for function argument timeout
(ANN001)
34-34: Unused function argument: timeout
(ARG001)
39-39: Unused lambda argument: cmd
(ARG005)
53-53: Missing type annotation for function argument monkeypatch
(ANN001)
53-53: Trailing comma missing
Add trailing comma
(COM812)
60-60: Missing return type annotation for private function fake_create_subprocess_exec
(ANN202)
60-60: Missing type annotation for *cmd
(ANN002)
60-60: Unused function argument: cmd
(ARG001)
60-60: Missing type annotation for **kwargs
(ANN003)
60-60: Unused function argument: kwargs
(ARG001)
63-63: Missing return type annotation for private function fake_wait_for_proc
(ANN202)
63-63: Missing type annotation for function argument proc
(ANN001)
63-63: Unused function argument: proc
(ARG001)
63-63: Missing type annotation for function argument path
(ANN001)
63-63: Unused function argument: path
(ARG001)
63-63: Missing type annotation for function argument idx
(ANN001)
63-63: Unused function argument: idx
(ARG001)
63-63: Async function definition with a timeout parameter
(ASYNC109)
63-63: Missing type annotation for function argument timeout
(ANN001)
63-63: Unused function argument: timeout
(ARG001)
68-68: Unused lambda argument: cmd
(ARG005)
🔇 Additional comments (8)
README.md (2)
43-43: LGTM!The usage syntax correctly shows the new optional
--verboseflag alongside the existing--concurrencyoption.
50-51: LGTM!The explanation clearly describes the purpose of the
--verboseflag, matching the implementation that logs the exactmermaid-clicommand for each diagram.nixie/cli.py (5)
7-7: LGTM!The
loggingandshleximports are correctly added to support the new verbose functionality.Also applies to: 10-10
126-126: LGTM!The verbose logging implementation correctly uses the module logger and
shlex.join()to create a shell-safe command string. The logging happens at INFO level, which is appropriate for this type of operational information.
221-221: LGTM!Adding the explicit return type annotation improves type safety and follows the coding guidelines.
238-242: LGTM!The
--verboseargument implementation is correct with appropriate help text that clearly describes the functionality.
249-252: LGTM!The logging configuration correctly sets INFO level when verbose is enabled and WARNING otherwise, with output directed to stderr as expected for CLI tools.
nixie/unittests/test_verbose.py (1)
15-77: LGTM on test logic!The test coverage is comprehensive and correctly validates both the argument parsing and the verbose logging behaviour. The tests properly mock the subprocess execution and verify that commands are logged only when verbose mode is enabled.
There was a problem hiding this comment.
Actionable comments posted: 2
♻️ Duplicate comments (1)
nixie/cli.py (1)
118-142: Well-documented function with comprehensive NumPy-style docstring.The docstring properly documents all parameters and return values in the required NumPy format. The documentation clearly explains the new logging behaviour when verbose mode is enabled.
📜 Review details
Configuration used: CodeRabbit UI
Review profile: ASSERTIVE
Plan: Pro
📒 Files selected for processing (2)
nixie/cli.py(6 hunks)nixie/unittests/test_verbose.py(1 hunks)
🧰 Additional context used
📓 Path-based instructions (3)
**/*.py
📄 CodeRabbit Inference Engine (AGENTS.md)
For Python files: Pass all relevant unit and behavioral tests, pass lint checks (
ruff check), adhere to formatting standards (ruff format), and pass type checking (pyright).
**/*.py: Use snake_case.py for file names, naming files for their contents (e.g., http_client.py, task_queue.py)
Use PascalCase for class names in Python files
Use snake_case for variable and function names in Python files
Use UPPER_SNAKE_CASE for module-level constants in Python files
Prefix private/internal helpers or APIs with a single underscore (_) in Python files
Use typing everywhere and maintain full static type coverage in Python files; use Pyright for type-checking
Use TypedDict or Dataclass for structured data where appropriate; for internal-only usage, prefer @DataClass(slots=True)
Avoid Any in type annotations; use Unknown, generics, or cast() when necessary, and always document why Any is acceptable if used
Be explicit with return types in public functions and class methods (e.g., use -> None, -> str, etc.)
Favor immutability in Python files; prefer tuples over lists, and frozendict or types.MappingProxyType where appropriate
Enable Ruff for linting and formatting; use Ruff to lint for performance, security, consistency, and style issues, and let Ruff handle whitespace and formatting entirely
Enforce strict mode in Pyright and treat all Pyright warnings as CI errors; use # pyright: ignore sparingly and with explanation
Avoid side effects at import time in Python modules; modules should not modify global state or perform actions on import
Use docstrings to document public functions, classes, and modules using NumPy format
Explain tricky code with inline comments for non-obvious logic or decisions in Python files
**/*.py: Use context managers to encapsulate setup and teardown logic cleanly and safely, especially for resource management (files, locks, connections, etc.), instead of manual try/finally blocks.
Use@contextmanagerfromcontextlibfor straightforward proce...
Files:
nixie/unittests/test_verbose.pynixie/cli.py
⚙️ CodeRabbit Configuration File
**/*.py: How about the following?- Keep cyclomatic complexity ≤ 12 - Follow single responsibility and CQRS (command/query segregation) - Docstrings must follow the `numpy` style guide. Use a single-line summary for private functions and methods, and full structured docs for all public interfaces. - Move conditionals with >2 branches to predicate/helper functions - Avoid `eval`, `exec`, `pickle`, monkey-patching, `ctypes`, unsafe shell - Every module must begin with a triple-quoted docstring explaining its purpose, utility, and usage, including example calls if appropriate. - Comments and docs must follow en-GB-oxendict (-ize / -our) spelling and grammar - Lint suppressions: - Blanket `# noqa`, file-level skips, and categories are **forbidden** - Only narrow in-line disables (`# noqa: XYZ`) are permitted, and must be accompanied by `FIXME:` or a ticket link, and used only as a last resort. - Use `pytest` fixtures for shared setup (`conftest.py` or `fixtures/`) - Replace duplicate tests with `@pytest.mark.parametrize` - Prefer `pytest-mock` or `unittest.mock` for stubs/mocks - Use `assert …, "message"` over bare asserts - Reflect all API/behaviour changes in `docs/` and update roadmap on completion - Files must not exceed 400 logical lines: - Decompose large modules into subpackages - Split large `match/case` or dispatch tables by domain and collocate with targets if appropriate - Move bulky data (fixtures, templates) to external files for parsing at runtime - Mutable defaults and shadowed built-ins are forbidden - All code must have clear type hints using modern style (`A | B`, `list[str]`, `class Foo[A]:`, `type Bar = int`, etc.), with ABC imports drawn from the correct stdlib module.
Files:
nixie/unittests/test_verbose.pynixie/cli.py
**/unittests/test_*.py
📄 CodeRabbit Inference Engine (.rules/python-00.mdc)
Colocate unit tests with code using a unittests subdirectory and a test_ prefix for test files
Files:
nixie/unittests/test_verbose.py
**/test_*.py
📄 CodeRabbit Inference Engine (.rules/python-00.mdc)
**/test_*.py: Use pytest idioms in test files: prefer fixtures over setup/teardown methods, parametrize broadly, and avoid unnecessary mocks
Group related tests using class with method names prefixed by test_ in test files
Files:
nixie/unittests/test_verbose.py
🪛 Ruff (0.12.2)
nixie/unittests/test_verbose.py
33-33: Unused function argument: cmd
(ARG001)
33-33: Unused function argument: kwargs
(ARG001)
37-37: Unused function argument: proc
(ARG001)
37-37: Unused function argument: path
(ARG001)
37-37: Unused function argument: idx
(ARG001)
37-37: Async function definition with a timeout parameter
(ASYNC109)
37-37: Unused function argument: timeout
(ARG001)
37-37: Trailing comma missing
Add trailing comma
(COM812)
66-66: Unused function argument: cmd
(ARG001)
66-66: Unused function argument: kwargs
(ARG001)
70-70: Unused function argument: proc
(ARG001)
70-70: Unused function argument: path
(ARG001)
70-70: Unused function argument: idx
(ARG001)
70-70: Async function definition with a timeout parameter
(ASYNC109)
70-70: Unused function argument: timeout
(ARG001)
70-70: Trailing comma missing
Add trailing comma
(COM812)
🔇 Additional comments (11)
nixie/cli.py (7)
7-7: LGTM! Import additions support the verbose logging feature.The addition of
loggingandshleximports is appropriate for the new verbose functionality that logs command-line invocations.Also applies to: 10-10
150-150: LGTM! Appropriate use of structured logging.The command-line logging uses the module-specific logger and
shlex.join()for proper shell escaping, which is exactly what's needed for debugging command execution.
190-194: Good formatting improvement for function signature readability.The multi-line parameter formatting enhances readability without changing the function's semantics.
203-211: Consistent formatting applied to function call.The multi-line parameter formatting matches the function definition style and improves code consistency.
245-245: Add explicit return type annotation as required by coding guidelines.The function now properly declares its return type as
argparse.Namespace, which improves type safety and follows the coding standards for explicit return types in public functions.
262-266: Well-implemented verbose flag with clear help text.The
--verboseargument follows standard CLI conventions withstore_trueaction and descriptive help text that clearly explains its purpose.
273-276: Proper logging configuration based on verbose flag.The logging setup correctly configures INFO level for verbose mode and WARNING level otherwise, directing output to stderr as appropriate for a CLI tool.
nixie/unittests/test_verbose.py (4)
1-13: LGTM! Proper module setup and imports.The imports are well-organised and include all necessary dependencies for testing the verbose logging functionality. The module follows the coding guidelines for import structure.
15-20: Well-structured test for argument parsing.The test properly verifies that the
--verboseflag is parsed correctly and that file paths are handled as expected. The use of monkeypatchingsys.argvis appropriate for testing CLI argument parsing.
45-52: Effective test for verbose logging behaviour.The test correctly verifies that the command line is logged at INFO level when verbose mode is enabled. The use of
caplog.at_level()and comparison with the expected command string is appropriate.
78-85: Excellent test for silent operation.This test properly verifies that command logging is suppressed when verbose mode is disabled by checking at WARNING level and asserting the command is not present in the log output.
1 participant
Summary
--verboseflag to print the command used for each diagramTesting
ruff check nixie testspyrightpython -m pytesthttps://chatgpt.com/codex/tasks/task_e_689301c1bbb48322ba6870284a282da2
Summary by Sourcery
Introduce a verbose mode that prints the exact mermaid-cli invocation for each diagram, update the CLI and core functions to accept and propagate the flag, document it in the README, and add tests to ensure correct behavior.
New Features:
Enhancements:
Documentation:
Tests: