mcp-coder-utils 0.1.2__tar.gz

mcp_coder_utils-0.1.2/.claude/CLAUDE.md

@@ -0,0 +1,87 @@
+## About this repo
+
+`mcp-coder-utils` is a **leaf library**: shared low-level Python helpers (subprocess, logging, fs) used by `mcp-coder`, `mcp-tools-py`, `mcp-workspace`, and `mcp-config`.
+
+**Architectural rules:**
+
+- Pure Python, language-agnostic. No ecosystem knowledge (no `pyproject.toml` parsing, no venv, no `.csproj`, no SQL).
+- Zero internal dependencies. Stdlib + pinned third-party libs only.
+- Every public function must have ≥2 real consumers. Single-user helpers stay in the consumer.
+- Public API is stable. Renames and signature changes break all 4 downstream repos.
+
+When in doubt, keep it in the consumer until a second consumer needs it.
+
+## MCP Tools — mandatory
+
+Use MCP tools for **all** operations. Never use `Read`, `Write`, `Edit`, or `Bash` for tasks that have an MCP equivalent.
+
+### Tool mapping
+
+| Task | MCP tool |
+|------|----------|
+| Read file | `mcp__workspace__read_file` |
+| Edit file | `mcp__workspace__edit_file` |
+| Write file | `mcp__workspace__save_file` |
+| Append to file | `mcp__workspace__append_file` |
+| Delete file | `mcp__workspace__delete_this_file` |
+| Move file | `mcp__workspace__move_file` |
+| List directory | `mcp__workspace__list_directory` |
+| Search files | `mcp__workspace__search_files` |
+| Read reference project | `mcp__workspace__read_reference_file` |
+| List reference dir | `mcp__workspace__list_reference_directory` |
+| Get reference projects | `mcp__workspace__get_reference_projects` |
+| Run pytest | `mcp__tools-py__run_pytest_check` |
+| Run pylint | `mcp__tools-py__run_pylint_check` |
+| Run mypy | `mcp__tools-py__run_mypy_check` |
+| Run lint-imports | `mcp__tools-py__run_lint_imports_check` |
+| Run vulture | `mcp__tools-py__run_vulture_check` |
+| Format code (black+isort) | `mcp__tools-py__run_format_code` |
+| Get library source | `mcp__tools-py__get_library_source` |
+| Refactoring | `mcp__tools-py__move_symbol`, `move_module`, `rename_symbol`, `list_symbols`, `find_references` |
+
+### Reference projects
+
+Read-only browse via `mcp__workspace__read_reference_file`:
+
+- `p_mcp_coder` — `mcp_coder` source
+- `p_workspace` — `mcp-workspace` source
+- `p_config` — `mcp-config` source
+- `p_tools` — `mcp-tools-py` source
+
+## Code quality checks
+
+After making code changes, run:
+
+```
+mcp__tools-py__run_pylint_check
+mcp__tools-py__run_pytest_check
+mcp__tools-py__run_mypy_check
+```
+
+All checks must pass before proceeding.
+
+**Pytest:** always use `extra_args: ["-n", "auto"]` for parallel execution. No integration test markers — run everything.
+
+## Git operations
+
+**Allowed commands via Bash:**
+
+```
+git status / diff / commit / log / fetch / ls-tree
+gh issue view / gh run view
+mcp-coder git-tool compact-diff    # diff that detects moves, collapses unchanged blocks
+mcp-coder check branch-status      # CI status, rebase needs, task completion, labels
+mcp-coder check file-size           # find files exceeding line-count threshold
+mcp-coder gh-tool set-status <label>  # change issue workflow status label
+```
+
+**Before every commit:** run `mcp__tools-py__run_format_code`, then stage and commit.
+
+**Bash discipline:** no `cd` prefix. Don't chain approved with unapproved commands. Run them separately.
+
+**Commit messages:** standard format, clear and descriptive. No attribution footers.
+
+## Writing style
+
+Be concise. If one line works, don't use three.
+

mcp_coder_utils-0.1.2/.claude/agents/commit-pusher.md

@@ -0,0 +1,24 @@
+---
+name: commit-pusher
+description: Commits and pushes code changes with pre-approved git operations
+tools:
+  - Bash
+  - Skill
+permissionMode: bypassPermissions
+---
+
+# Commit-Pusher Agent
+
+You are a commit and push specialist. Invoke the /commit_push skill.
+
+Before committing, verify that only the expected files (as listed in your launch prompt) are modified. If unexpected files are changed, stop and report back.
+
+## Why `bypassPermissions`?
+
+This agent uses `bypassPermissions` so that git add/commit/push commands are auto-approved
+without adding them to the global permissions allow list. This is intentional:
+
+- The **main conversation** must NOT have git add/commit/push permissions
+- Only this agent (reachable via `/commit_push` skill) should be able to commit
+- `acceptEdits` only auto-approves file edit tools (Edit/Write), not Bash commands
+- `bypassPermissions` auto-approves all tool calls within this agent's scope

mcp_coder_utils-0.1.2/.claude/knowledge_base/planning_principles.md

@@ -0,0 +1,28 @@
+# Planning Principles
+
+## Step Design
+
+- **Merge tiny or intertwined steps.** Steps that are trivially small or tightly coupled should be combined. However, prefer several small steps over fewer large ones — small steps fit better in LLM context windows.
+- **Split large steps.** Ideally each step can be completed such that pylint/pytest/mypy still pass afterward.
+- **One step = one commit.** Each step should produce exactly one commit: write tests, implement, verify checks pass. If a step needs multiple fix-and-commit cycles, split it into smaller steps.
+- **No separate "fix all issues" steps.** Quality checks passing is an exit criterion for each step, not a separate step.
+- **No "verify everything" cleanup steps.** If each step leaves checks green, a final verification step is unnecessary. If you find yourself planning one, the earlier steps are too large.
+- **Every step must have tangible results.** No preparation steps like "read docs" or "explore codebase" — analysis happens as part of implementation.
+- **No need to fill in task tracker during planning.** This is done automatically as step 0 of implementation.
+- **No rollback options needed.** Don't plan for how to undo steps.
+
+## Testing
+
+- **No manual tests.** All tests must be automated.
+- **Test structure mirrors src structure.** Tests for `src/foo/bar.py` go in `tests/foo/test_bar.py`.
+- **Parameterized tests** are a good idea to reduce the number of required test functions while covering more cases.
+
+## Code Quality
+
+- **If uncertain about the codebase, analyze it.** Don't guess — read the code and understand before planning changes.
+- **If a question implies worsening code quality**, include small refactorings in the plan to actually improve it.
+
+## Documentation
+
+- **Docstrings** should document functions well, without examples.
+- **CLI commands** should be documented via CLI help text and in the `docs/` folder.

mcp_coder_utils-0.1.2/.claude/knowledge_base/python.md

@@ -0,0 +1,6 @@
+# Python Guidelines
+
+- **f-strings are preferred.**
+- **Use type hint syntax appropriate for the project's minimum supported Python version.**
+- **Avoid conditional imports.** If a dependency is missing, stop and escalate to the user rather than working around it.
+- **Tests for optional resources should skip, not fake.** When a test depends on something that may not be available (an optional SDK, a database, an API, a CLI tool), use `pytest.importorskip` or `pytest.mark.skipif` to skip transparently. Don't mock the resource just to make the test run everywhere — skipping is honest and avoids false confidence.

mcp_coder_utils-0.1.2/.claude/knowledge_base/refactoring_principles.md

@@ -0,0 +1,22 @@
+# Refactoring Principles
+
+Quick reference for refactoring rules and tools. For detailed process, examples, and checklists, see the [Safe Refactoring Guide](../../docs/processes-prompts/refactoring-guide.md).
+
+## Key Rules
+
+- **Move, don't change.** Logic changes belong in a separate PR.
+- **Only adjust imports.** Use `move_symbol` — it updates imports automatically.
+- **Clean deletion, no legacy artifacts.** No stubs, no re-exports for backward compatibility.
+- **Small steps.** One module per PR. Keep diffs under 25,000 tokens.
+- **Tests mirror source structure.**
+
+## Process
+
+1. Plan target structure
+2. Move source code — `move_symbol` / `move_module`
+3. Move tests to mirror new structure
+4. Review diff — `mcp-coder git-tool compact-diff` (remaining diff should be imports only)
+5. Run all checks — pytest, pylint, mypy, ruff
+6. Check file sizes — `mcp-coder check file-size --max-lines 750`
+
+See [Safe Refactoring Guide](../../docs/processes-prompts/refactoring-guide.md) for the full checklist.

mcp_coder_utils-0.1.2/.claude/knowledge_base/software_engineering_principles.md

@@ -0,0 +1,30 @@
+# Software Engineering Principles
+
+## Quality Baseline
+
+- **Every change should leave the code better than before.** Not just "no worse" — actively better. This is the expectation, not a stretch goal.
+- **Boy Scout Rule** — when you touch a file, look for one small improvement: fix a misleading name, remove dead code you just created, clean an import you just changed. One good deed per PR, not a renovation.
+- **Don't change working code for cosmetic reasons** when it's already readable.
+
+## Code Review Scope
+
+- **Pre-existing issues are out of scope.** Note them if important, but don't block the review or create fix-up work. File a separate issue if needed.
+- **Review findings fall into three buckets:**
+  1. **Critical** — must fix before merge (bugs, regressions, security)
+  2. **Accept** — worth fixing now, bounded effort (Boy Scout fixes)
+  3. **Skip** — cosmetic, speculative, or pre-existing
+- **If a change only matters when someone makes a future mistake, it's speculative — skip it.**
+
+## Code Style
+
+- **Clean Code, DRY, KISS** — encourage these consistently.
+- **YAGNI** — don't build for hypothetical future requirements.
+- **Test behavior, not implementation.** Cover the contract, not every corner.
+- **Prefer readable code over comments.** If the code needs a comment to be understood, first try to make the code clearer. Add comments only when the *why* isn't obvious from the code itself.
+- **Code duplication should be avoided**, especially when refactoring. No need to keep old interfaces.
+
+## Don't Worry About
+
+- **Line count estimates** — precise line numbers and line counts are not crucial. The LLM is not good at counting. Minor updates are not relevant.
+- **Commit messages** — no need to clean them up if they have minor issues.
+- **pr_info/ folder** — deleted later during the process. Can be read as background information.

mcp_coder_utils-0.1.2/.claude/settings.local.json

@@ -0,0 +1,68 @@
+{
+  "permissions": {
+    "allow": [
+      "mcp__tools-py__run_pylint_check",
+      "mcp__tools-py__run_pytest_check",
+      "mcp__tools-py__run_mypy_check",
+      "mcp__tools-py__run_lint_imports_check",
+      "mcp__tools-py__run_vulture_check",
+      "mcp__tools-py__run_format_code",
+      "mcp__tools-py__list_symbols",
+      "mcp__tools-py__find_references",
+      "mcp__tools-py__move_symbol",
+      "mcp__tools-py__rename_symbol",
+      "mcp__tools-py__move_module",
+      "mcp__tools-py__get_library_source",
+      "mcp__workspace__get_reference_projects",
+      "mcp__workspace__list_reference_directory",
+      "mcp__workspace__read_reference_file",
+      "mcp__workspace__list_directory",
+      "mcp__workspace__read_file",
+      "mcp__workspace__save_file",
+      "mcp__workspace__append_file",
+      "mcp__workspace__delete_this_file",
+      "mcp__workspace__move_file",
+      "mcp__workspace__edit_file",
+      "Bash(git status:*)",
+      "Bash(git diff:*)",
+      "Bash(git log:*)",
+      "Bash(git fetch:*)",
+      "Bash(git ls-tree:*)",
+      "Bash(gh run view:*)",
+      "Bash(gh issue view:*)",
+      "Bash(mcp-coder check file-size:*)",
+      "Bash(mcp-coder check branch-status:*)",
+      "Bash(mcp-coder gh-tool:*)",
+      "Bash(mcp-coder git-tool:*)",
+      "Bash(find:*)",
+      "Bash(ruff rule:*)",
+      "Bash(ruff check:*)",
+      "Skill(commit_push)",
+      "Skill(discuss)",
+      "Skill(implementation_approve)",
+      "Skill(implementation_finalise)",
+      "Skill(implementation_needs_rework)",
+      "Skill(implementation_new_tasks)",
+      "Skill(implementation_review)",
+      "Skill(implementation_review_supervisor)",
+      "Skill(issue_analyse)",
+      "Skill(issue_approve)",
+      "Skill(issue_create)",
+      "Skill(issue_update)",
+      "Skill(plan_approve)",
+      "Skill(plan_review)",
+      "Skill(plan_review_supervisor)",
+      "Skill(plan_update)",
+      "Skill(rebase)",
+      "Skill(check_branch_status)",
+      "Skill(implement_direct)",
+      "WebFetch(domain:*)",
+      "mcp__workspace__search_files"
+    ]
+  },
+  "enableAllProjectMcpServers": true,
+  "enabledMcpjsonServers": [
+    "tools-py",
+    "workspace"
+  ]
+}

mcp_coder_utils-0.1.2/.claude/skills/check_branch_status/SKILL.md

@@ -0,0 +1,22 @@
+---
+description: Check branch readiness including CI, rebase needs, tasks, and labels
+disable-model-invocation: true
+allowed-tools:
+  - "Bash(mcp-coder check branch-status *)"
+---
+
+!`mcp-coder check branch-status --ci-timeout 180 --llm-truncate`
+
+# Check Branch Status
+
+Checks CI status, rebase needs, task completion, and GitHub labels. Reports actionable recommendations.
+
+## Follow-Up Actions
+
+| Status | Action |
+|--------|--------|
+| CI failures | Fix the issues shown in CI error details |
+| Rebase needed | `/rebase` |
+| Tasks incomplete | Complete remaining tasks manually |
+| CI green + tasks done | `/commit_push` or create PR |
+| Ready to merge | Create PR or merge via GitHub |

mcp_coder_utils-0.1.2/.claude/skills/commit_push/SKILL.md

@@ -0,0 +1,48 @@
+---
+description: Format code, review changes, commit, and push to remote
+disable-model-invocation: true
+allowed-tools:
+  - "Bash(git status *)"
+  - "Bash(git diff *)"
+  - "Bash(git add *)"
+  - "Bash(git commit *)"
+  - "Bash(git push *)"
+  - "Bash(git log *)"
+  - mcp__tools-py__run_format_code
+  - Read
+  - Glob
+  - Grep
+---
+
+# Commit and Push Changes
+
+Follow this process to commit and push your changes:
+
+## 1. Format Code
+Use `mcp__tools-py__run_format_code` to format all code (black + isort).
+
+## 2. Review Changes
+```bash
+git status
+git diff
+```
+
+## 3. Stage Changes
+Stage all relevant changes (exclude any files that shouldn't be committed).
+
+## 4. Commit
+Create a commit with a clear, conventional commit message:
+- Use format: `type(scope): description`
+- Types: feat, fix, docs, style, refactor, test, chore
+- Keep summary under 50 characters
+- **No Claude Code footer or attribution in commit message**
+
+## 5. Push
+```bash
+git push
+```
+
+If the branch doesn't exist on remote yet:
+```bash
+git push -u origin HEAD
+```

mcp_coder_utils-0.1.2/.claude/skills/discuss/SKILL.md

@@ -0,0 +1,16 @@
+---
+description: Step-by-step discussion of open questions and suggestions
+disable-model-invocation: true
+---
+
+# Step-by-step Discussion
+
+Interactively walk through all open suggestions, questions, and proposed changes one by one.
+
+Can we go through all open suggested changes and questions step by step?
+You explain, ask and I answer until we discussed all topics?
+Please offer, whenever possible, simple options like 
+- A
+- B
+- C
+Always just ask ONE question

mcp_coder_utils-0.1.2/.claude/skills/implement_direct/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: implement-direct
+disable-model-invocation: true
+argument-hint: [issue-number]
+allowed-tools:
+  - "Bash(gh issue view *)"
+  - "Bash(mcp-coder gh-tool *)"
+  - mcp__workspace__read_file
+  - mcp__tools-py__run_format_code
+---
+
+# Implement Direct
+
+Implement a small, well-defined issue directly — no planning phase, no task tracker.
+
+## Resolve Issue Number
+
+The user may provide an issue number as the argument (available as `$ARGUMENTS`).
+If no issue number is provided:
+1. Read `.vscodeclaude_status.txt` and extract the issue number from the `Issue #NNN` line
+2. If the file doesn't exist or has no issue number, ask the user
+
+## Steps
+
+1. **Fetch issue details**
+   ```bash
+   gh issue view <issue_number>
+   ```
+   Read the issue title, description, and acceptance criteria carefully.
+
+2. **Checkout/create issue branch**
+   ```bash
+   mcp-coder gh-tool checkout-issue-branch <issue_number>
+   ```
+
+3. **Understand context**
+   - Read relevant source files referenced in the issue
+   - Understand the existing code patterns and conventions
+   - Identify the minimal set of changes needed
+
+4. **Implement changes**
+   - Make the required code changes directly
+   - Follow existing code patterns and conventions
+   - Keep changes focused and minimal — only what the issue requires
+
+5. **Run quality checks**
+   - `mcp__tools-py__run_pylint_check` — fix all issues
+   - `mcp__tools-py__run_pytest_check` (with `extra_args: ["-n", "auto"]`) — fix all failures
+   - `mcp__tools-py__run_mypy_check` — fix all issues
+   - `./tools/ruff_check.sh` — fix all issues
+
+6. **Format code**
+   Use `mcp__tools-py__run_format_code` to format all code (black + isort).
+
+7. **Update issue status**
+   ```bash
+   mcp-coder gh-tool set-status status-07:code-review
+   ```
+
+8. **Suggest follow-up steps**
+   - `/commit_push` — commit and push changes
+   - `/check_branch_status` — verify branch is clean
+   - `/implementation_review` — request a review of the implementation
+
+## Scope Guidance
+
+This skill is designed for **small, well-defined issues** that can be implemented in a single pass. If the issue is complex or involves multiple components, recommend the full workflow instead:
+
+1. `/create_plan` — create a detailed implementation plan
+2. `/implement` — implement the plan step by step
+
+**Note:** This skill has `disable-model-invocation` — it can only be run by the user typing `/implement_direct`.

mcp_coder_utils-0.1.2/.claude/skills/implementation_approve/SKILL.md

@@ -0,0 +1,33 @@
+---
+description: Approve implementation and transition issue to PR-ready state
+disable-model-invocation: true
+allowed-tools:
+  - "Bash(mcp-coder gh-tool set-status *)"
+  - "Bash(mcp-coder check branch-status *)"
+---
+
+# Approve Implementation
+
+Approve the implementation and transition the issue to PR-ready state.
+
+**Instructions:**
+1. Run branch-status check:
+```bash
+mcp-coder check branch-status --ci-timeout 400 --pr-timeout 600 --llm-truncate
+```
+
+2. If `branch-status` reports a base branch other than `main`, ask the user to confirm this is intentional before proceeding.
+
+3. Only if the branch-status check passes (exit code 0), run the set-status command and confirm it succeeded:
+```bash
+mcp-coder gh-tool set-status status-08:ready-pr
+```
+
+**Note:** If the branch-status check fails, report the failures to the user and do not set the label. If the set-status command fails, report the error to the user. Do not use `--force` unless explicitly asked.
+
+**Effect:** Changes issue status from `status-07:code-review` to `status-08:ready-pr`.
+
+4. After the label is set, poll for the PR to be created and pass CI. This runs in the background — the background process creates the PR while it polls (up to 600s):
+```bash
+mcp-coder check branch-status --ci-timeout 400 --pr-timeout 600 --llm-truncate --wait-for-pr
+```

mcp_coder_utils-0.1.2/.claude/skills/implementation_finalise/SKILL.md

@@ -0,0 +1,52 @@
+---
+description: Complete remaining unchecked tasks in the task tracker
+disable-model-invocation: true
+---
+
+# Implementation Finalise
+
+Complete any remaining unchecked tasks in the task tracker before transitioning to code review.
+
+## Process
+
+### 1. Read Task Tracker
+
+Read `pr_info/TASK_TRACKER.md` and identify all unchecked tasks (`- [ ]`).
+
+If all tasks are already checked (`- [x]`), report that no finalisation is needed and exit.
+
+### 2. Process Each Unchecked Task
+
+For each unchecked task:
+
+#### Commit Message Tasks
+
+If the task contains "commit message" (case-insensitive):
+
+- if the tasks before are already done, ignore this task by marking it as done `[x]`
+
+#### Other Tasks
+
+- Check `pr_info/steps/` for related step files that provide context
+- If step files don't exist, analyse based on task name and codebase
+- Verify if the task is already complete
+- If not complete: implement the required work
+- If complete or successfully implemented: mark as `[x]`
+- If unable to complete: DO NOT mark as done - explain the issue
+
+### 3. Quality Checks (If Code Changed)
+
+If any code changes were made during this process:
+
+- Run pylint checks using the MCP server (fix all errors)
+- Run pytest checks using the MCP server (fix all failures)
+- Run mypy checks using the MCP server (fix all type errors)
+
+## Output
+
+Report:
+
+1. Which tasks were processed
+2. Which tasks were marked complete
+3. Any issues encountered
+4. Summarize the changes in a commit message and report it

mcp_coder_utils-0.1.2/.claude/skills/implementation_needs_rework/SKILL.md

@@ -0,0 +1,35 @@
+---
+description: Return issue to plan-ready status for re-implementation after major review issues
+disable-model-invocation: true
+allowed-tools:
+  - "Bash(mcp-coder gh-tool set-status *)"
+---
+
+# Return to plan-ready after major review issues
+
+Transitions the issue back to `plan-ready` status for re-implementation when code review identifies major issues that cannot be fixed with minor changes.
+
+## When to Use
+
+| Situation | Action |
+|-----------|--------|
+| Minor fixes | Fix directly, re-run `/implementation_review` or `/implementation_review_supervisor` |
+| **Major issues** | **This command** (after `/implementation_new_tasks` + `/commit_push`) |
+| Approved | `/implementation_approve` |
+
+## Prerequisites
+
+- New implementation steps created (`/implementation_new_tasks`)
+- Changes committed and pushed (`/commit_push`)
+
+## Instructions
+
+```bash
+mcp-coder gh-tool set-status status-05:plan-ready
+```
+
+Confirm the status change was successful. If it fails, report the error. Do not use `--force` unless explicitly asked.
+
+## Next Steps
+
+Run `mcp-coder implement` to process the new steps, then `/implementation_review` or `/implementation_review_supervisor`.

mcp_coder_utils-0.1.2/.claude/skills/implementation_new_tasks/SKILL.md

@@ -0,0 +1,36 @@
+---
+description: Create additional implementation steps after code review findings
+disable-model-invocation: true
+allowed-tools:
+  - mcp__workspace__read_file
+  - mcp__workspace__save_file
+  - mcp__workspace__edit_file
+  - mcp__workspace__list_directory
+---
+
+# Create Further Implementation Tasks
+
+Append new implementation tasks to the project plan after code review identified areas needing additional work.
+
+## Instructions
+
+Please expand the **implementation plan** stored under `pr_info/steps`
+Update the `pr_info/steps/Decisions.md` with the decisions we took.
+Please create additional self-contained steps (`pr_info/steps/step_1.md`, `pr_info/steps/step_2.md`, etc.).
+Please update the **summary** (`pr_info/steps/summary.md`).
+
+### Requirements for the new implementation steps:
+- Follow **Test-Driven Development** where applicable.
+  Each step should have its own test implementation followed by related functionality implementation.
+- Each step must include a **clear LLM prompt** that references the summary and that specific step
+- Apply **KISS principle** - minimize complexity, maximize maintainability
+- Keep code changes minimal and follow best practices
+
+### Each Step Must Specify:
+- **WHERE**: File paths and module structure
+- **WHAT**: Main functions with signatures
+- **HOW**: Integration points (decorators, imports, etc.)
+- **ALGORITHM**: 5-6 line pseudocode for core logic (if any)
+- **DATA**: Return values and data structures
+
+Please also update the task tracker (`pr_info/TASK_TRACKER.md`).

mcp_coder_utils-0.1.2/.claude/skills/implementation_review/SKILL.md

@@ -0,0 +1,53 @@
+---
+description: Code review of implementation with compact diff analysis
+disable-model-invocation: true
+allowed-tools:
+  - "Bash(git fetch *)"
+  - "Bash(git status *)"
+  - "Bash(git diff *)"
+  - "Bash(mcp-coder git-tool *)"
+  - "Bash(mcp-coder check branch-status *)"
+  - mcp__workspace__read_file
+  - mcp__workspace__list_directory
+  - Glob
+  - Grep
+---
+
+# Implementation Review (Code Review)
+
+**First, ensure we're up to date:**
+```bash
+git fetch
+git status
+mcp-coder check branch-status --llm-truncate
+```
+
+Confirm and display the current feature branch name.
+
+---
+
+**Then run the code review:**
+
+## Code Review Request
+
+Run this command to get the changes to review:
+```bash
+mcp-coder git-tool compact-diff
+```
+
+No need to run all checks; do not use pylint warnings. Feel free to further analyse any mentioned files and/or the file structure.
+
+### Focus Areas:
+- Logic errors or bugs
+- Tests for `__main__` functions should be removed (not needed)
+- Unnecessary debug code or print statements
+- Code that could break existing functionality
+- Compliance with existing architecture principles, see `docs/architecture/architecture.md`
+
+### Output Format:
+1. **Summary** - What changed (1-2 sentences)
+2. **Critical Issues** - Must fix before merging
+3. **Suggestions** - Nice to have improvements
+4. **Good** - What works well
+
+Do not perform any action. Just present the code review.