/besimple-tiny-broccoli

name: besimple-tiny-broccoli
description: "Small-change wrapper: implement → run repo checks → atomic commit → run dedup (BASE_SHA..HEAD)."

Tiny Broccoli: Implement → Check → Commit → Dedup

Use this when the user request is already clear and you can safely implement directly (no plan docs), but you still want: 1) repo checks to be green, and 2) a dedupe pass over the resulting diff.

Not for

• Big/ambiguous work that needs research, design decisions, or a multi-phase plan.
• “Refactor the whole repo” style requests.

Preconditions (hard stop if missing)

• Confirm you are in the intended repo: `git rev-parse --show-toplevel`
• Start from a clean working tree: `git status --porcelain` is empty
• Ensure git can create commits (`user.name` / `user.email` configured)
• Ensure required CLIs exist (dedup requires distinct vendors): `codex`, `claude`

Required subskills

• `dedup`

Workflow

0) Record `BASE_SHA` (required)

Capture the base ref **before any changes** (used later for `dedup`):

BASE_SHA="$(git rev-parse HEAD)"

1) Choose the repo check command(s) once (required)

Do a one-time **tooling detection + configuration** so the per-step “build/lint” commands match the target repo.

**Detect languages and entrypoints**

• **Node/TS**: look for `package.json` in repo root and common subprojects (for example `functions/package.json`).
• **Python**: look for `pyproject.toml`, `uv.lock`, `poetry.lock`, `requirements.txt`.

**Pick build/lint/typecheck commands (prefer repo-native scripts)**

• Prefer existing package scripts when present (e.g. `npm run build`, `npm run lint`, `npm test`).
• Prefer the repo’s configured Python toolchain:
• If `uv` is clearly in use: use `uv`-based commands.
• If Poetry is clearly in use: use `poetry run ...`.
• If neither: use the repo’s documented commands (README/CONTRIBUTING) if available.
• If multiple options exist or it’s unclear, ask the user **once** for the canonical build/lint/typecheck commands, then reuse them for every step.

**Write down a “Tooling config” block and reuse it for every step**

• Example format (adapt to the repo):
• **Root (Node)**: build=`...`, lint=`...`
• **functions/ (Node)**: build=`...`, lint=`...`
• **Root (Python)**: build=`...`, typecheck=`...`, lint/format=`...`
• From now on, *only* run the commands from this block after each step (instead of hard-coded defaults).

**If the repo has no build/lint tooling**

• Explicitly record “No build/lint configured” and skip build/lint steps (do not invent tooling). Call this out in the final summary.

2) Implement the requested change (required)

• Make the smallest correct change that satisfies the request.
• Prefer reusing existing patterns/utilities over creating new ones.
• Keep the change set small and reviewable.

3) Run repo checks and fix only what you broke (required)

• Run the commands from your **Tooling config**.
• If checks fail due to changes you introduced, fix and re-run until green.
• If checks fail for clearly pre-existing/unrelated reasons, stop and report:
• the exact command(s) you ran, and
• the first actionable error output.

4) Commit once checks are green (required)

• `git add -A`
• Make a single atomic commit for the user-requested change:
• `git commit -m "<imperative summary>"` (example: `Fix flaky upload retry`).
• Do not create empty/no-op commits (`--allow-empty` is prohibited).

5) Run `dedup` against `BASE_SHA` (required)

Ensure the working tree is clean, then run the dedupe loop:

if [ -n "$(git status --porcelain)" ]; then
  echo "Working tree is not clean; commit or stash before running dedup." >&2
  exit 1
fi

resolve_skill_dir() {
  local name="$1"
  local repo_root=""
  repo_root="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"

  local candidates=(
    "$repo_root/.agents/skills/$name"
    "$repo_root/.claude/skills/$name"
    "$HOME/.agents/skills/$name"
    "$HOME/.codex/skills/$name"
    "$HOME/.claude/skills/$name"
  )

  for d in "${candidates[@]}"; do
    if [[ -d "$d" ]]; then
      echo "$d"
      return 0
    fi
  done

  echo "Error: skill '$name' not found in repo-scoped or user-scoped skill dirs." >&2
  return 1
}

DEDUP_SKILL_DIR="$(resolve_skill_dir dedup)"
python3 "$DEDUP_SKILL_DIR/scripts/run_dedup_loop.py" "${BASE_SHA}"

If `dedup` creates additional commits, re-run the **Tooling config** checks once at the end and fix only issues introduced by dedupe changes. Do not interrupt/restart the dedup loop if it looks quiet; the loop script owns timeouts and retries.

Guardrails

• Keep changes tightly scoped to the user request + required dedupe.
• Avoid drive-by refactors, renames, formatting-only churn, or dependency upgrades unless required.
• End state must be: checks green (or explicitly “no checks configured”), clean working tree, and at least one meaningful commit.