Erd 1633 reproduce ci locally tool

.gitignore

@@ -0,0 +1 @@
+*.pyc

.helper_bash_functions

@@ -44,18 +44,37 @@ for d in sys.argv[1:]:
                         print(f"    ... ({len(lines) - 20} more lines)")
 PYEOF
 }
+_find_verbose_test_packages() {
+    local requested_packages="$1"
+    local verbose_packages=""
+    while IFS=$'\t' read -r name path _; do
+        if echo " ${requested_packages} " | grep -q " ${name} "; then
+            if [ -f "${path}/.verbose_tests" ]; then
+                verbose_packages="${verbose_packages} ${name}"
+            fi
+        fi
+    done < <(colcon list 2>/dev/null)
+    echo "${verbose_packages## }"
+}
 colcon_test_these_packages() { THIS_DIR=$(pwd)
                                cd ${CATKIN_WS_PATH}
                                colcon_build_no_deps $1
-                               source install/setup.bash && \
-                               colcon test --packages-select $1
+                               source install/setup.bash
+                               local verbose_packages
+                               verbose_packages=$(_find_verbose_test_packages "$1")
+                               if [ -n "${verbose_packages}" ]; then
+                                   echo -e "${Yellow}Packages with verbose tests: ${verbose_packages}${Color_Off}"
+                                   colcon test --packages-select $1 --packages-skip ${verbose_packages}
+                                   colcon test --packages-select ${verbose_packages} --event-handlers console_direct+
+                               else
+                                   colcon test --packages-select $1
+                               fi
                                for pkg in $1; do
                                    if ! colcon test-result --test-result-base "build/$pkg/test_results"; then
                                        _show_test_failures "build/$pkg/test_results"
                                    fi
                                done
                                cd $THIS_DIR
-
 }
 colcon_test_this_package() { colcon_test_these_packages "$@"; }  # Alias for backwards compatability
 find_cmake_project_names_from_dir() { if [[ -z $1 ]]; then DIR_TO_SEARCH="."; else DIR_TO_SEARCH=$1; fi; wget -qO- https://raw.githubusercontent.com/Extend-Robotics/er_build_tools/refs/heads/main/bin/find_cmake_project_names.py | python3 - $DIR_TO_SEARCH; }
@@ -136,11 +155,35 @@ ps_aux() { ps aux | cgrep $1 | grep -v grep ; }
 kill_any_process() { ps_aux_command $1; conf="$(confirm "kill these processes? [Y/n]")"; if [[ $conf == "y" ]]; then echo "killing..."; sudo kill -9 $(ps_aux $1 | awk {'print $2}'); sleep 1; echo "remaining: "; ps_aux_command $1 else echo "not killing"; fi ; }
 docker_exec () { if [[ $(docker container ls -q | wc -l) -eq 1 ]]; then docker exec -it $(docker container ls -q) bash; else echo "wrong number of containers running"; fi; }
 awk_line_length() { if [[ -z $2 ]]; then MAX_LINE_LENGTH=200; else MAX_LINE_LENGTH=$2; fi; cat $1 | awk 'length($0) < '"$MAX_LINE_LENGTH"''; }
-update_helper_bash_functions() { if [ ! -f ~/.helper_bash_functions ]; then
-                                   echo -e "${Red}ERROR: Tried to replace this file but couldn't find it, something has gone wrong!${Color_Off}\n"
-                                   return
-                                 fi
-                                 wget -O ~/.helper_bash_functions ${THIS_SCRIPT_URL}
+MERGE_VARS_URL="https://raw.githubusercontent.com/Extend-Robotics/er_build_tools/refs/heads/${THIS_SCRIPT_BRANCH}/bin/merge_helper_vars.py"
+
+update_helper_bash_functions() {
+    if [ ! -f ~/.helper_bash_functions ]; then
+        echo -e "${Red}ERROR: Tried to replace this file but couldn't find it, something has gone wrong!${Color_Off}\n"
+        return 1
+    fi
+
+    local tmp_new
+    tmp_new=$(mktemp)
+    if ! wget -q -O "${tmp_new}" "${THIS_SCRIPT_URL}"; then
+        echo -e "${Red}Error: Failed to download updated helper_bash_functions${Color_Off}"
+        rm -f "${tmp_new}"
+        return 1
+    fi
+
+    local merge_script
+    merge_script=$(curl -fSL "${MERGE_VARS_URL}") || {
+        echo -e "${Red}Error: Failed to fetch merge_helper_vars.py${Color_Off}"
+        rm -f "${tmp_new}"
+        return 1
+    }
+
+    python3 <(echo "${merge_script}") ~/.helper_bash_functions "${tmp_new}"
+    cp "${tmp_new}" ~/.helper_bash_functions
+    rm -f "${tmp_new}"
+
+    echo ""
+    echo -e "${Green}helper_bash_functions updated. Run 'source ~/.helper_bash_functions' to reload.${Color_Off}"
 }
 
 # python linters
@@ -203,6 +246,64 @@ remove_ci_container() {
     echo -e "${Green}Container '${container_name}' removed${Color_Off}"
 }
 
+# CI tool (Python CLI) - interactive CI reproduction + Claude-powered fix
+CI_TOOL_CACHE_DIR="${HOME}/.ci_tool"
+CI_TOOL_RAW_URL="https://raw.githubusercontent.com/Extend-Robotics/er_build_tools/refs/heads/${THIS_SCRIPT_BRANCH}/bin/ci_tool"
+CI_TOOL_FILES="__init__.py __main__.py cli.py preflight.py containers.py ci_reproduce.py claude_setup.py ci_fix.py claude_session.py display_progress.py requirements.txt"
+CI_TOOL_DATA_FILES="ci_context/CLAUDE.md"
+
+install_ci_tool() {
+    echo -e "${Yellow}Installing ci_tool from er_build_tools (branch: ${THIS_SCRIPT_BRANCH})...${Color_Off}"
+    mkdir -p "${CI_TOOL_CACHE_DIR}/ci_tool"
+    local failed="false"
+    for file in ${CI_TOOL_FILES}; do
+        echo "  Fetching ${file}..."
+        if ! curl -fSL "${CI_TOOL_RAW_URL}/${file}" -o "${CI_TOOL_CACHE_DIR}/ci_tool/${file}"; then
+            echo -e "${Red}  Failed to fetch ${file}${Color_Off}"
+            failed="true"
+        fi
+    done
+    for file in ${CI_TOOL_DATA_FILES}; do
+        echo "  Fetching ${file}..."
+        mkdir -p "${CI_TOOL_CACHE_DIR}/ci_tool/$(dirname "${file}")"
+        if ! curl -fSL "${CI_TOOL_RAW_URL}/${file}" -o "${CI_TOOL_CACHE_DIR}/ci_tool/${file}"; then
+            echo -e "${Red}  Failed to fetch ${file}${Color_Off}"
+            failed="true"
+        fi
+    done
+    if [ "${failed}" = "true" ]; then
+        echo -e "${Red}Error: Failed to install ci_tool. Check network and branch '${THIS_SCRIPT_BRANCH}'.${Color_Off}"
+        return 1
+    fi
+    echo -e "${Green}ci_tool installed to ${CI_TOOL_CACHE_DIR}${Color_Off}"
+}
+
+update_ci_tool() { install_ci_tool; }
+
+ci_tool() {
+    mkdir -p "${CI_TOOL_CACHE_DIR}/ci_tool"
+    local fetch_failed="false"
+    for file in ${CI_TOOL_FILES}; do
+        if ! curl -fsSL "${CI_TOOL_RAW_URL}/${file}" -o "${CI_TOOL_CACHE_DIR}/ci_tool/${file}" 2>/dev/null; then
+            fetch_failed="true"
+        fi
+    done
+    for file in ${CI_TOOL_DATA_FILES}; do
+        mkdir -p "${CI_TOOL_CACHE_DIR}/ci_tool/$(dirname "${file}")" 2>/dev/null
+        if ! curl -fsSL "${CI_TOOL_RAW_URL}/${file}" -o "${CI_TOOL_CACHE_DIR}/ci_tool/${file}" 2>/dev/null; then
+            fetch_failed="true"
+        fi
+    done
+    if [ "${fetch_failed}" = "true" ]; then
+        if [ ! -f "${CI_TOOL_CACHE_DIR}/ci_tool/__main__.py" ]; then
+            echo -e "${Red}Error: Failed to fetch ci_tool and no cached version available${Color_Off}"
+            return 1
+        fi
+        echo -e "${Yellow}Warning: Failed to fetch latest ci_tool, using cached version${Color_Off}"
+    fi
+    python3 "${CI_TOOL_CACHE_DIR}/ci_tool" "$@"
+}
+ci_fix() { ci_tool fix "$@"; }
 
 
 er_python_linters_here() { local ret=0

CLAUDE.md

@@ -0,0 +1,71 @@
+# er_build_tools
+
+Public build tools and CI utilities for Extend Robotics ROS1 repositories. The main component is `ci_tool`, an interactive CLI that reproduces CI failures locally in Docker and uses Claude Code to fix them.
+
+## Project Structure
+
+```
+bin/
+  ci_tool/              # Main Python package
+    __main__.py         # Entry point (auto-installs missing deps)
+    cli.py              # Menu dispatch router
+    ci_fix.py           # Core workflow: reproduce -> Claude analysis -> fix -> shell
+    ci_reproduce.py     # Docker container setup for CI reproduction
+    claude_setup.py     # Install Claude + copy credentials/config into container
+    claude_session.py   # Interactive Claude session launcher
+    containers.py       # Docker lifecycle (create, exec, cp, remove)
+    preflight.py        # Auth/setup validation (fail-fast)
+    display_progress.py # Stream-json output processor for Claude
+    ci_context/
+      CLAUDE.md         # CI-specific instructions for Claude inside containers
+  setup.sh              # User-facing setup script
+  reproduce_ci.sh       # Public wrapper for CI reproduction
+.helper_bash_functions  # Sourced by users; provides colcon/rosdep helpers + ci_tool alias
+pylintrc                # Pylint config (strict: fail-under=10.0, max-line-length=140)
+```
+
+## Code Style
+
+- Python 3.6+, `from __future__ import annotations` in all modules
+- snake_case everywhere; PascalCase for classes only
+- 4-space indentation, max 140 char line length
+- Pylint must pass at 10.0 (`pylintrc` at repo root)
+- Use `# pylint: disable=...` pragmas only when essential, with justification
+- Interactive prompts via `InquirerPy`; terminal UI via `rich`
+
+## Conventions
+
+- **Fail fast**: `PreflightError` for expected failures, `RuntimeError` for unexpected. No silent defaults, no fallback behaviour.
+- **Minimal diffs**: Only change what's requested. No cosmetic cleanups, no "while I'm here" changes.
+- **Self-documenting code**: Verbose variable names. Comments only for maths or external doc links.
+- **Subprocess calls**: Use `docker_exec()` / `run_command()` from `containers.py`. Pass `check=False` when non-zero is expected; `quiet=True` to suppress echo.
+- **State files**: `/ros_ws/.ci_fix_state.json` inside containers (session_id, phase, attempt_count)
+- **Learnings persistence**: `~/.ci_tool/learnings/{org}_{repo}.md` on host, `/ros_ws/.ci_learnings.md` in container
+
+## Environment Variables
+
+- `GH_TOKEN` or `ER_SETUP_TOKEN` — GitHub token (checked in preflight)
+- `CI_TOOL_SCRIPTS_BRANCH` — branch of er_build_tools_internal to fetch scripts from
+- `IS_SANDBOX=1` — injected into all docker exec calls for Claude
+
+## Running
+
+```bash
+# From host
+source ~/.helper_bash_functions
+ci_tool          # interactive menu
+ci_fix           # shortcut for ci_tool fix
+
+# Lint
+pylint --rcfile=pylintrc bin/ci_tool/
+```
+
+## Testing
+
+No unit tests yet. Test manually by running `ci_tool` workflows end-to-end.
+
+## Common Pitfalls
+
+- Container Claude settings must use valid `defaultMode` values: `"acceptEdits"`, `"bypassPermissions"`, `"default"`, `"dontAsk"`, `"plan"`. The old `"dangerouslySkipPermissions"` is invalid.
+- `docker_cp_to_container` requires the container to be running.
+- Claude inside containers runs with `--dangerously-skip-permissions` flag (separate from the settings.json mode).

README.md

@@ -2,11 +2,95 @@
 
 Public build tools and utilities for Extend Robotics repositories.
 
-## reproduce_ci.sh — Reproduce CI Locally
+## Quick Setup
+
+Install helper bash functions, set your GitHub token, and authenticate Claude:
+
+```bash
+bash <(curl -fsSL https://raw.githubusercontent.com/Extend-Robotics/er_build_tools/refs/heads/main/bin/setup.sh)
+```
+
+This installs `~/.helper_bash_functions` which provides build helpers, git aliases, and `ci_tool`.
+
+## ci_tool: Fix CI Failures with Claude
+
+`ci_tool` is an interactive CLI that reproduces CI failures locally in Docker and uses Claude Code to fix them.
+
+### Prerequisites
+
+- **Docker** installed and running
+- **Claude Code** installed and authenticated: `npm install -g @anthropic-ai/claude-code && claude`
+- **GitHub token** with `repo` scope: [create one](https://github.com/settings/tokens)
+
+### Usage
+
+```bash
+source ~/.helper_bash_functions
+ci_tool
+```
+
+This opens an interactive menu. You can also run subcommands directly — see `ci_tool --help`:
+
+```
+$ ci_tool --help
+ci_tool — Fix CI failures with Claude
+
+Usage: ci_tool [command]
+
+Commands:
+  fix          Fix CI failures with Claude
+  reproduce    Reproduce CI environment in Docker
+  claude       Interactive Claude session in container
+  shell        Shell into an existing CI container
+  retest       Re-run tests in a CI container
+  clean        Remove CI containers
+
+Shortcuts:
+  ci_fix       Alias for 'ci_tool fix'
+
+Run without arguments for interactive menu.
+```
+
+### Fix Workflow
+
+1. Run `ci_fix`
+2. Create a new session or reuse an existing container
+3. Optionally paste a GitHub Actions URL to target a specific failure
+4. ci_tool reproduces the CI environment in Docker
+5. Claude analyses the test output and applies fixes
+6. You're dropped into a shell to review changes, commit, and push
+
+### Manual Setup
+
+If you prefer not to use the setup script:
+
+1. Download helper functions:
+   ```bash
+   curl -fsSL https://raw.githubusercontent.com/Extend-Robotics/er_build_tools/refs/heads/main/.helper_bash_functions \
+     -o ~/.helper_bash_functions
+   ```
+2. Add your GitHub token to the top of `~/.helper_bash_functions`:
+   ```bash
+   export GH_TOKEN="ghp_your_token_here"
+   ```
+3. Source in your shell:
+   ```bash
+   echo 'source ~/.helper_bash_functions' >> ~/.bashrc
+   source ~/.helper_bash_functions
+   ```
+4. Install and authenticate Claude Code:
+   ```bash
+   npm install -g @anthropic-ai/claude-code
+   claude
+   ```
+
+---
+
+## reproduce_ci.sh: Reproduce CI Locally
 
 When CI fails, debugging requires pushing commits and waiting for results. This script reproduces the exact CI environment locally in a persistent Docker container, so you can debug interactively.
 
-It creates a Docker container using the same image as CI, clones your repo and its dependencies, builds everything, and optionally runs tests — mirroring the steps in `setup_and_build_ros_ws.yml`.
+It creates a Docker container using the same image as CI, clones your repo and its dependencies, builds everything, and optionally runs tests, mirroring the steps in `setup_and_build_ros_ws.yml`.
 
 ### Quick Start
 
@@ -98,8 +182,8 @@ docker rm -f er_ci_reproduced_testing_env
 
 ### Troubleshooting
 
-**Container already exists** — Remove it first: `docker rm -f er_ci_reproduced_testing_env`
+**Container already exists**: Remove it first: `docker rm -f er_ci_reproduced_testing_env`
 
-**404 when fetching scripts** — Check that your `--gh-token` has access to `er_build_tools_internal`, and that the `--scripts-branch` exists.
+**404 when fetching scripts**: Check that your `--gh-token` has access to `er_build_tools_internal`, and that the `--scripts-branch` exists.
 
-**`DISPLAY` error with graphical forwarding** — Either set `DISPLAY` (e.g. via X11 forwarding) or pass `--graphical false`.
+**`DISPLAY` error with graphical forwarding**: Either set `DISPLAY` (e.g. via X11 forwarding) or pass `--graphical false`.

bin/ci_tool/TODO.md

@@ -0,0 +1,35 @@
+# ci_tool TODO
+
+## Features
+
+- [ ] **Analyse CI mode**: Implement the plan in `docs/plans/2026-02-25-ci-analyse-mode-plan.md`. New "Analyse CI" menu item with two sub-modes: "Remote only (fast)" fetches GH Actions logs, filters with regex, diagnoses with Claude haiku on host — no Docker. "Remote + local reproduction" runs both in parallel with a Rich Live split-panel display, then offers to transition into fix mode. New files: `ci_analyse.py`, `ci_analyse_display.py`, `ci_log_filter.py`.
+- [x] ~~**Parallel CI analysis during local reproduction**~~: Superseded by the Analyse CI mode above.
+
+## UX
+
+- [ ] **Simplify the main menu**: Too many top-level options (reproduce, fix, claude, shell, retest, clean, exit). Several overlap — e.g. "Reproduce CI" is already a step within "Fix CI with Claude", and "Claude session" / "Shell into container" / "Re-run tests" are all post-reproduce actions on an existing container. Consolidate into fewer choices and push the rest into sub-menus or contextual prompts.
+
+## Bug Fixes
+
+- [ ] If branch name is empty/blank, default to the repo's default branch instead of requiring input
+- [ ] In "Reproduce CI (create container)" mode, extract the branch name from the GitHub Actions URL (like `extract_info_from_ci_url` already does in "Fix CI with Claude" mode) instead of requiring the user to enter it manually
+
+## Done
+- [x] ~~Render markdown in terminal~~ — display_progress.py now buffers text between tool calls and renders via `rich.markdown.Markdown` (tables, headers, code blocks, bold/italic)
+- [x] ~~Empty workspace after reproduce~~ — `_docker_exec_workspace_setup()` distinguishes setup failures from test failures; `wstool scrape` fixed in internal repo
+- [x] ~~Silent failures~~ — 21 issues audited and fixed across all modules
+- [x] ~~resume_claude auth~~ — `IS_SANDBOX=1` passed via `docker exec -e` on all calls (`.bashrc` not sourced by non-interactive shells)
+- [x] ~~gh CLI auth warning~~ — removed redundant `gh auth login` (GH_TOKEN env var handles auth)
+- [x] ~~Token efficiency~~ — prompts updated to use grep instead of reading full logs
+- [x] ~~Persistent learnings~~ — `~/.ci_tool/learnings/{org}_{repo}.md` persists between sessions
+
+## Testing
+
+- [ ] Add unit tests for each module, leveraging the clean separation of concerns:
+  - **ci_reproduce.py**: `_parse_repo_url` (edge cases: trailing slashes, `.git` suffix, invalid URLs, non-GitHub URLs), `_fetch_github_raw_file` (HTTP errors, timeouts, bad tokens), `prompt_for_reproduce_args` / `prompt_for_repo_and_branch` (input validation)
+  - **ci_fix.py**: `extract_run_id_from_url` (valid/invalid/malformed URLs), `extract_info_from_ci_url` (API errors, missing fields, bad URLs), `gather_session_info` (all input combinations: with/without CI URL, new/resume, empty fields)
+  - **containers.py**: `sanitize_container_name`, `container_exists`/`container_is_running` (mock docker calls)
+  - **preflight.py**: each check in isolation (mock docker/gh/claude)
+  - **cli.py**: `dispatch_subcommand` routing, `_handle_container_collision` (all three choices)
+- [ ] Input validation / boundary tests: verify weird input combinations at module boundaries (e.g. gather_session_info output dict is always valid input for reproduce_ci, prompt outputs satisfy reproduce_ci preconditions)
+- [ ] Integration-style tests: mock Docker/GitHub and run full flows end-to-end (new session, resume session, reproduce-only)

bin/ci_tool/__main__.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+"""Entry point for: python3 -m ci_tool or python3 /path/to/ci_tool"""
+import os
+import subprocess
+import sys
+
+ci_tool_dir = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, os.path.dirname(ci_tool_dir))
+
+try:
+    from ci_tool.cli import main
+except ImportError:
+    requirements_file = os.path.join(ci_tool_dir, "requirements.txt")
+    subprocess.check_call(
+        [sys.executable, "-m", "pip", "install", "--user", "--quiet",
+         "-r", requirements_file]
+    )
+    from ci_tool.cli import main
+
+if __name__ == "__main__":
+    main()