claude-dev-env 1.34.1 → 1.36.0

package/agents/xlsx-agent.md

@@ -1,169 +0,0 @@
----
-name: xlsx-agent
-description: Use this agent when working with Excel spreadsheets requiring complex formulas, formatting, financial modeling, or data analysis.
-model: inherit
-color: green
----
-
-You are an Excel spreadsheet specialist agent complementing the xlsx skill.
-
-**Complementary Skill:** skills/xlsx/SKILL.md
-**Your Role:** Handle complex spreadsheet projects, delegate simple operations to the skill
-
-## Complexity Assessment
-
-**Handle as agent (complex) when:**
-- Creating multi-worksheet workbooks with interconnected formulas
-- Financial modeling requiring industry-standard formatting (color-coding, number formats)
-- Formula debugging across multiple files or sheets
-- Projects requiring systematic formula verification via recalc.py
-- Merging/transforming data across multiple Excel files
-- Creating complex reports with charts, pivot tables, and formatting
-- Extracting and analyzing data from multiple spreadsheet sources
-- Projects requiring both openpyxl (formulas) AND pandas (data analysis)
-
-**Delegate to skill (simple) when:**
-- Reading single Excel file into DataFrame
-- Simple data extraction from one sheet
-- Basic CSV conversion
-- Straightforward table extraction with pdfplumber
-- Single formula creation or edit
-- Simple metadata extraction
-
-## Workflow for Complex Tasks
-
-1. **Load methodology** - Invoke Skill tool to load xlsx skill
-2. **Create TodoWrite** - Track phases:
-   ```
-   Excel Project:
-   - [ ] Requirements analysis (worksheets, formulas, formatting)
-   - [ ] Implementation (openpyxl or pandas based on needs)
-   - [ ] Formula verification (recalc.py if formulas used)
-   - [ ] Error fixing (if verification fails)
-   - [ ] Final validation
-   ```
-3. **Gather requirements:**
-   - What type of workbook? (Financial model, report, data analysis)
-   - Formula complexity? (Simple calculations vs. multi-sheet dependencies)
-   - Formatting requirements? (Financial standards, custom styles)
-   - Data sources? (CSV, database, API, manual entry)
-4. **Choose tools based on skill guidance:**
-   - **openpyxl** for formulas, formatting, Excel-specific features
-   - **pandas** for data manipulation, bulk operations, analysis
-   - Both if needed (data processing → formatted output)
-5. **Implement with skill patterns:**
-   - Use frozen dataclasses for configuration
-   - Extract constants (financial color codes, number formats)
-   - Follow skill's formula construction rules (cell references, no hardcoding)
-   - Apply financial modeling standards if applicable
-6. **MANDATORY - Verify formulas:**
-   - If ANY formulas created, run: `python recalc.py output.xlsx`
-   - Check JSON output for errors
-   - If errors found, iterate fixes until clean
-7. **Follow skill quality guidelines:**
-   - Zero formula errors (non-negotiable)
-   - Document hardcoded values with sources
-   - Preserve existing template conventions when updating files
-   - Use Excel formulas, not Python-calculated hardcoded values
-
-## Critical Skill Rules to Enforce
-
-### ALWAYS Use Excel Formulas (Never Hardcode Calculated Values)
-
-❌ **WRONG:**
-```python
-# Calculating in Python and hardcoding result
-total = df['Sales'].sum()
-sheet['B10'] = total  # Hardcodes 5000 - spreadsheet can't recalculate
-```
-
-✅ **CORRECT:**
-```python
-# Let Excel calculate with formulas
-sheet['B10'] = '=SUM(B2:B9)'  # Spreadsheet recalculates when source data changes
-```
-
-**Why this matters:** Spreadsheets must remain dynamic. Hardcoded values break when source data changes.
-
-### Financial Modeling Standards (When Applicable)
-
-Only apply when user indicates financial modeling context:
-- **Blue text:** Hardcoded inputs users will change
-- **Black text:** ALL formulas and calculations
-- **Green text:** Links from other worksheets in same workbook
-- **Red text:** External file links
-- **Yellow background:** Key assumptions needing attention
-
-### Formula Verification is Mandatory
-
-After creating ANY file with formulas:
-```bash
-python recalc.py output.xlsx
-```
-
-If errors found (status: "errors_found"), MUST fix before delivering to user.
-
-## Delegation Path
-
-If assessment shows simple task:
-```
-Use Skill tool with: skills/xlsx
-Exit after delegation
-```
-
-## Common Complex Scenarios
-
-**Financial Model Creation:**
-1. Define model structure (income statement, balance sheet, cash flow, valuation)
-2. Create worksheet templates with headers
-3. Build formulas with cell references to assumptions
-4. Apply financial color-coding standards
-5. Verify all formulas calculate correctly
-6. Document assumptions and sources
-
-**Multi-File Data Consolidation:**
-1. Read multiple Excel files with pandas
-2. Transform and merge data
-3. Create summary workbook with openpyxl
-4. Add formulas linking to consolidated data
-5. Format output with consistent styles
-6. Verify formulas work
-
-**Report Generation:**
-1. Extract data from database/API/CSV
-2. Process with pandas (aggregations, calculations)
-3. Create formatted Excel output with openpyxl
-4. Add charts and pivot tables
-5. Apply conditional formatting
-6. Verify all formulas
-
-## Edge Cases to Handle
-
-**Existing Template Modification:**
-- MUST preserve existing format, style, and conventions
-- Study template carefully before making changes
-- Never impose standardized formatting on established templates
-- Existing patterns ALWAYS override skill guidelines
-
-**Formula Errors:**
-- Common: #REF! (invalid references), #DIV/0! (division by zero), #VALUE! (wrong type)
-- Use recalc.py to identify all errors
-- Fix systematically (verify cell references, check ranges, test edge cases)
-- Re-run verification until clean
-
-**Mixed Workbook/Pandas Tasks:**
-- Use pandas for data transformation and analysis
-- Use openpyxl for final formatted output with formulas
-- Never mix in same step (data first, then formatting)
-
-## Output Deliverables
-
-**For Simple Tasks (delegated):**
-- Delegate to skill, provide result
-
-**For Complex Tasks:**
-- Working Excel file(s) with zero formula errors
-- Verification output showing all formulas calculated successfully
-- Documentation of any hardcoded values with sources
-- Brief explanation of formula logic for key calculations
-- Instructions for user on how to modify assumptions/inputs

package/skills/bugteam/scripts/README.md

@@ -1,58 +0,0 @@
-# Bugteam utility scripts
-
-Scripts in this directory are **executed** by the lead or teammates. They are not loaded into context as instructions (see Anthropic [Skill authoring best practices — Progressive disclosure](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices#progressive-disclosure-patterns)).
-
-| Script | Purpose |
-|--------|---------|
-| `bugteam_preflight.py` | Run pytest (when configured) and optional `pre-commit` before `/bugteam`. |
-| `bugteam_fix_hookspath.py` | Auto-remediate a stale local `core.hooksPath` override, set canonical global value, re-run `bugteam_preflight.py`. Invoked by Claude when preflight reports a `core.hooksPath` failure. |
-| `bugteam_code_rules_gate.py` | Run `validate_content` from `code-rules-enforcer.py` on PR-scoped files (`git diff` vs merge-base). Exit `1` if any mandatory rule fails. Invoked **before each audit**; the fixer clears it before the auditor runs. |
-| `grant_project_claude_permissions.py` | Idempotent grant of Edit/Write/Read on `cwd/.claude/**` into `~/.claude/settings.json`. |
-| `revoke_project_claude_permissions.py` | Removes the matching grant entries from `~/.claude/settings.json`. |
-| `test_claude_permissions_common.py` | Pytest module for path normalization and glob-metacharacter guards in `_claude_permissions_common.py`. |
-| `_claude_permissions_common.py` | Shared helpers for the grant/revoke scripts (atomic JSON writes, settings sections). |
-
-## `bugteam_preflight.py`
-
-From the repository root:
-
-```bash
-python "${CLAUDE_SKILL_DIR}/scripts/bugteam_preflight.py"
-```
-
-- Skips pytest when `BUGTEAM_PREFLIGHT_SKIP=1`.
-- Skips pytest when `pytest.ini` / `pyproject.toml` exists but no `test_*.py` / `*_test.py` files are found under the repo root.
-- Pytest exit code `5` (no tests collected) is treated as success.
-- Add `--pre-commit` to run `pre-commit run --all-files` when `.pre-commit-config.yaml` exists.
-
-## `bugteam_fix_hookspath.py`
-
-From the repository root:
-
-```bash
-python "${CLAUDE_SKILL_DIR}/scripts/bugteam_fix_hookspath.py"
-```
-
-- Removes any local-scope `core.hooksPath` value that does not end in `hooks/git-hooks`.
-- Sets `git config --global core.hooksPath ~/.claude/hooks/git-hooks` when the global value is unset or non-canonical.
-- Refuses to run (exit non-zero) when `~/.claude/hooks/git-hooks` does not exist on disk — install via `npx claude-dev-env .` first.
-- Idempotent: a second invocation is a clean no-op.
-- Re-runs `bugteam_preflight.py --no-pytest` and propagates its exit code.
-
-The bugteam SKILL invokes this automatically when preflight stderr indicates a `core.hooksPath` failure, so Claude does not surface the error to the user.
-
-## `bugteam_code_rules_gate.py`
-
-From the repository root (same merge-base rules as the PR head vs base — default `--base origin/main`):
-
-```bash
-python "${CLAUDE_SKILL_DIR}/scripts/bugteam_code_rules_gate.py"
-```
-
-Optional explicit files instead of `git diff`:
-
-```bash
-python "${CLAUDE_SKILL_DIR}/scripts/bugteam_code_rules_gate.py" path/to/a.py path/to/b.ts
-```
-
-This loads `validate_content` from `hooks/blocking/code-rules-enforcer.py` inside `claude-dev-env` (same logic as the PreToolUse hook). Exit `0` = mandatory checks pass on scanned files; exit `1` = violations printed to stderr.

package/skills/bugteam/scripts/_claude_permissions_common.py

@@ -1,219 +0,0 @@
-"""Shared helpers for grant_project_claude_permissions and revoke_project_claude_permissions.
-
-Writes to ~/.claude/settings.json are atomic and permission-preserving: the
-target file's existing POSIX mode is captured, a sibling temp file is
-created via os.open with O_CREAT | O_EXCL and the preserved mode, content
-is written, then os.replace swaps it into place. Output is serialized with
-sort_keys=True for a stable on-disk layout; the first run on a hand-ordered
-settings file produces a one-time re-sort diff, subsequent writes are stable.
-"""
-
-import json
-import os
-import stat
-import sys
-from pathlib import Path
-from typing import NoReturn
-
-
-TEXT_FILE_ENCODING: str = "utf-8"
-PERMISSION_ALLOW_TOOLS: tuple[str, ...] = ("Edit", "Write", "Read")
-
-AUTO_MODE_ENVIRONMENT_ENTRY_TEMPLATE: str = (
-    "Trusted local workspace: {project_path}/.claude/** is the user's "
-    "project Claude Code config tree; edits inside are routine"
-)
-
-
-def exit_with_error(message: str) -> NoReturn:
-    print(f"Error: {message}", file=sys.stderr)
-    raise SystemExit(1)
-
-
-def path_contains_glob_metacharacters(candidate_path: str) -> bool:
-    glob_metacharacters_in_path: tuple[str, ...] = (
-        "*",
-        "?",
-        "[",
-        "]",
-        "(",
-        ")",
-        "{",
-        "}",
-        ",",
-    )
-    return any(
-        each_character in candidate_path
-        for each_character in glob_metacharacters_in_path
-    )
-
-
-def get_current_project_path() -> str:
-    normalized_project_path = str(Path.cwd()).replace("\\", "/")
-    if path_contains_glob_metacharacters(normalized_project_path):
-        raise ValueError(
-            f"Current directory path contains glob metacharacters and cannot "
-            f"be used to build permission rules safely: {normalized_project_path}"
-        )
-    return normalized_project_path
-
-
-def build_permission_rule(tool_name: str, project_path: str) -> str:
-    return f"{tool_name}({project_path}/.claude/**)"
-
-
-def build_permission_rules(
-    project_path: str, permission_allow_tools: tuple[str, ...]
-) -> list[str]:
-    return [
-        build_permission_rule(each_tool, project_path)
-        for each_tool in permission_allow_tools
-    ]
-
-
-def load_settings(settings_path: Path) -> dict[str, object]:
-    if not settings_path.exists():
-        return {}
-    parsed_settings: dict[str, object] = {}
-    try:
-        raw_text = settings_path.read_text(encoding=TEXT_FILE_ENCODING)
-    except OSError as read_error:
-        exit_with_error(f"Failed to read {settings_path}: {read_error}")
-    try:
-        parsed_settings = json.loads(raw_text)
-    except json.JSONDecodeError as decode_error:
-        exit_with_error(
-            f"Refusing to modify {settings_path}: existing file is not valid JSON "
-            f"({decode_error}). Fix or back up the file manually, then re-run."
-        )
-    if not isinstance(parsed_settings, dict):
-        exit_with_error(
-            f"Refusing to modify {settings_path}: existing file's root is "
-            f"{type(parsed_settings).__name__}, not a JSON object. Fix or back up "
-            f"the file manually, then re-run."
-        )
-    return parsed_settings
-
-
-def serialize_settings_to_json_text(settings: dict[str, object]) -> str:
-    json_indent_width_columns: int = len("  ")
-    return json.dumps(
-        settings,
-        indent=json_indent_width_columns,
-        sort_keys=True,
-    )
-
-
-def get_mode_to_preserve(settings_path: Path) -> int:
-    default_settings_file_mode: int = 0o600
-    try:
-        stat_result = os.stat(settings_path)
-    except FileNotFoundError:
-        return default_settings_file_mode
-    except OSError as stat_error:
-        exit_with_error(f"Failed to stat {settings_path}: {stat_error}")
-    return stat.S_IMODE(stat_result.st_mode)
-
-
-def write_atomically_with_mode(
-    temporary_path: Path, serialized_content: str, file_mode: int
-) -> None:
-    file_descriptor = os.open(
-        str(temporary_path),
-        os.O_WRONLY | os.O_CREAT | os.O_EXCL,
-        file_mode,
-    )
-    with os.fdopen(file_descriptor, "w", encoding=TEXT_FILE_ENCODING) as writer:
-        writer.write(serialized_content)
-
-
-def save_settings(settings_path: Path, settings: dict[str, object]) -> None:
-    atomic_write_temporary_suffix: str = ".tmp"
-    settings_path.parent.mkdir(parents=True, exist_ok=True)
-    serialized_settings = serialize_settings_to_json_text(settings)
-    temporary_path = settings_path.with_suffix(
-        settings_path.suffix + atomic_write_temporary_suffix
-    )
-    mode_to_preserve = get_mode_to_preserve(settings_path)
-    try:
-        try:
-            write_atomically_with_mode(
-                temporary_path, serialized_settings, mode_to_preserve
-            )
-            os.replace(str(temporary_path), str(settings_path))
-        except OSError as os_error:
-            exit_with_error(
-                f"Failed to write settings atomically to {settings_path}: {os_error}"
-            )
-    finally:
-        if temporary_path.exists():
-            try:
-                temporary_path.unlink()
-            except OSError:
-                pass
-
-
-def append_if_missing(target_list: list[object], new_value: str) -> bool:
-    if new_value in target_list:
-        return False
-    target_list.append(new_value)
-    return True
-
-
-def ensure_dict_section(
-    settings: dict[str, object], section_name: str
-) -> dict[str, object]:
-    """Return an existing dict section or create an empty one if absent.
-
-    A missing key and an explicit JSON null are treated identically: both
-    produce a fresh empty dict stored back into settings. Any other non-dict
-    value (string, list, number, bool) calls exit_with_error to avoid
-    overwriting user data.
-    """
-    existing_section = settings.get(section_name)
-    if existing_section is None:
-        replacement_section: dict[str, object] = {}
-        settings[section_name] = replacement_section
-        return replacement_section
-    if not isinstance(existing_section, dict):
-        exit_with_error(
-            f"Refusing to modify settings key {section_name!r}: existing value "
-            f"is {type(existing_section).__name__}, not a JSON object. Fix or "
-            f"remove the key manually, then re-run."
-        )
-    return existing_section
-
-
-def ensure_list_entry(section: dict[str, object], entry_name: str) -> list[object]:
-    """Return an existing list entry or create an empty one if absent.
-
-    A missing key and an explicit JSON null are treated identically: both
-    produce a fresh empty list stored back into the section. Any other
-    non-list value (string, dict, number, bool) calls exit_with_error to
-    avoid overwriting user data.
-    """
-    existing_entry = section.get(entry_name)
-    if existing_entry is None:
-        replacement_entry: list[object] = []
-        section[entry_name] = replacement_entry
-        return replacement_entry
-    if not isinstance(existing_entry, list):
-        exit_with_error(
-            f"Refusing to modify settings entry {entry_name!r}: existing value "
-            f"is {type(existing_entry).__name__}, not a JSON array. Fix or "
-            f"remove the entry manually, then re-run."
-        )
-    return existing_entry
-
-
-def prune_empty_list_then_empty_section(
-    settings: dict[str, object], section_key: str, list_key: str
-) -> None:
-    section = settings.get(section_key)
-    if not isinstance(section, dict):
-        return
-    list_entry = section.get(list_key)
-    if isinstance(list_entry, list) and len(list_entry) == 0:
-        del section[list_key]
-    if len(section) == 0:
-        del settings[section_key]