Setup

Purpose

Every reference the plugin prints, every lane's collector order, the scope exclusions, and the coverage artifact paths resolve through one consumer surface, .claude/code-metrics.yaml, layered as user-global (~/.claude/code-metrics.yaml), team (tracked), and local overlay (.claude/code-metrics.local.yaml, gitignored) with per-key override. All three layers absent is a valid state: every key has a bundled default. This skill is the check-centric setup for that surface and for the external collectors the audits probe: check inspects and verifies, apply persists, and neither installs anything. Keys, defaults, and provenance: ${CLAUDE_PLUGIN_ROOT}/reference/config.md.

Action routing: no argument or check runs the check; apply runs the check first, then persists. apply is non-interactive when complete <key>=<value> arguments are supplied (automation and headless use pass them and are never prompted); with none, it interviews one key at a time, recommendation first.

check (read-only)

Run and present the table as printed:

"${CLAUDE_SKILL_DIR}/scripts/setup-check.sh"

Rows, each PASS, FAIL, WARN, or INFO:

1. python: the interpreter resolved (python3, python, or py -3) and the plugin's floor. FAIL stops the table: Python is required for correctness, so name the remediation.
2. layer user-global / team / local: absent (INFO), or present and parsed in the YAML subset the plugin reads (block mappings, block sequences, flow sequences of scalars, scalars, comments). A flow mapping, anchor, tag, or block scalar is FAIL with its line; the operator rewrites the file in block style.
3. layer team tracked: git check-ignore -v on the team file reports no match (a match is FAIL with the rule: an ignored team layer never reaches the team) and git ls-files --error-unmatch sees it (untracked is WARN: written but uncommitted).
4. layer local ignored: the overlay is gitignored, else WARN with the recommended consumer line .claude/**/*.local.*. Recommend the line; never edit the consumer's .gitignore.
5. ecosystem <lane>.yaml: each consumer ecosystem file parses; its globs and enabled override lane detection.
6. reference <measure>: the resolved value with the layer that supplied it and its provenance, so a personal layer that changed a value is visible.
7. collector <tool>: PASS with the version when the adapter's probe resolves the tool on PATH; INFO missing with the install hint otherwise. Missing is not a failure: the lane reports unavailable at audit time and the run continues.

Exit 0 with no FAIL row, 1 with one, 2 on a usage or environment error.

apply (idempotent)

1. Run check and read its table.

2. Resolve the values. With complete <key>=<value> arguments, use them directly. Otherwise interview one key at a time, recommendation first, walking the annotated template ${CLAUDE_SKILL_DIR}/templates/config-template.yaml (every key with its default and provenance, in the subset; the key reference is ${CLAUDE_PLUGIN_ROOT}/reference/config.md): the cyclomatic reference (20, ISO/IEC 5055 §8.2.117; 10 and 15 are the cited alternatives), the file-length reference (1000, the plugin's own number; 500 selectable) and size.mode, scope exclusions, coverage artifact paths, per-lane opt-outs and collector order, duplication registries. Offer every declared key, preserve every key the existing file carries, and never invent a key beyond the contract. A key outside the contract is written but reported, because unknown keys are inert to the plugin.

3. Persist. One call per run, every value as <key>=<value> in the YAML subset:

   "${CLAUDE_SKILL_DIR}/scripts/setup-apply.py" size.file_lines=500 'scope.exclude=["vendor/**"]'
   

   The script merges per key into the repository root's .claude/code-metrics.yaml (the root git reports from the current directory; --dir <root> or --file <path> overrides it), writes block style, and prints already configured without touching the file when nothing changes.

4. Verify. Re-run check; report the persisted values from its table, never from the write alone. The tracked-file pair decides the outcome: a WARN written but untracked means "commit it to share with the team", never success; an ignored team file is FAIL and the operator's .gitignore is theirs to fix.

Output

check: the table. apply: the table before and after, the written path, and one line on how to re-run this skill to reconfigure. Say which layer supplied each reference that differs from the bundled default.

What this skill does NOT do

• Install, download, or npx-fetch a collector. It prints install hints; the operator installs.
• Write the user-global or local layers. Those are personal files the operator edits.
• Write Claude Code user settings or pluginConfigs; the plugin has no userConfig.
• Edit the consumer's .gitignore; it recommends the one recursive line.
• Run an audit. The audit skills read the same resolved document at run time.

Next

/code-metrics:audit-complexity. The sibling audit-* skills cover the other measures.

Gotchas

• The team file must be committed to reach the team; apply leaves it untracked on purpose and the check row says so until it is committed.
• apply judges idempotence on parsed content, so hand-written comments never force a rewrite by themselves; a value that differs does, and the file is rewritten in block style.
• A layer written with a flow mapping ({ enabled: true }) is outside the subset; every audit reports the file as unreadable with the line, and check shows the same row.
• size.mode: iso-8.2.115 needs a collector that reports function ranges (lizard, radon); Bash has none, and its row says so.