codeforge-dev 1.8.0 → 1.9.0

package/.devcontainer/plugins/devs-marketplace/plugins/auto-code-quality/README.md

@@ -0,0 +1,158 @@
+# auto-code-quality
+
+Self-contained Claude Code plugin that automatically formats and lints edited files. Drop it into any Claude Code plugin marketplace and enable it — no other plugins required.
+
+## What It Does
+
+Three-phase pipeline that runs transparently during your Claude Code session:
+
+1. **Collect** (PostToolUse on Edit/Write) — Records which files Claude edits
+2. **Format** (Stop hook) — Batch-formats all edited files when Claude finishes responding
+3. **Lint** (Stop hook) — Batch-lints all edited files and surfaces warnings as context
+
+Additionally validates JSON, JSONC, YAML, and TOML syntax immediately after each edit.
+
+All phases are non-blocking. Missing tools are silently skipped. The plugin always exits cleanly — it will never interrupt Claude.
+
+## Required Tools
+
+Install the tools for the languages you work with. Everything is optional — the plugin gracefully skips any tool that isn't found.
+
+| Language | Formatter | Linter(s) | Install |
+|----------|-----------|-----------|---------|
+| Python | [ruff](https://docs.astral.sh/ruff/) | [pyright](https://github.com/microsoft/pyright), ruff check | `pip install ruff` / `npm i -g pyright` |
+| Python (fallback) | [black](https://github.com/psf/black) | — | `pip install black` |
+| Go | gofmt (bundled with Go) | go vet (bundled with Go) | [Install Go](https://go.dev/dl/) |
+| JS/TS/CSS/GraphQL/HTML | [biome](https://biomejs.dev/) | biome lint | `npm i -D @biomejs/biome` or `npm i -g @biomejs/biome` |
+| Shell | [shfmt](https://github.com/mvdan/sh) | [shellcheck](https://github.com/koalaman/shellcheck) | `brew install shfmt shellcheck` |
+| Markdown/YAML/TOML | [dprint](https://dprint.dev/) | — | `brew install dprint` |
+| Dockerfile | dprint | [hadolint](https://github.com/hadolint/hadolint) | `brew install hadolint` |
+| Rust | rustfmt (bundled with Rust) | clippy (bundled with Rust) | [Install Rust](https://rustup.rs/) |
+| JSON/JSONC/YAML/TOML | — | syntax-validator (Python stdlib) | No extra install needed |
+
+### dprint Configuration
+
+The dprint formatter looks for a config file at `/usr/local/share/dprint/dprint.json`. If this file doesn't exist, dprint formatting is skipped. Create one with your preferred settings, or use a minimal config:
+
+```json
+{
+  "markdown": {},
+  "toml": {},
+  "yaml": {}
+}
+```
+
+### Biome Discovery
+
+Biome is resolved in this order:
+1. Project-local: walks up from the edited file looking for `node_modules/.bin/biome`
+2. Global: checks PATH via `which biome`
+
+## Installation
+
+### 1. Place the plugin
+
+Copy the `auto-code-quality/` directory into your Claude Code plugin marketplace:
+
+```
+your-marketplace/
+├── .claude-plugin/
+│   └── marketplace.json
+└── plugins/
+    └── auto-code-quality/    ← this directory
+```
+
+### 2. Register in marketplace.json
+
+Add this entry to your `marketplace.json` `plugins` array:
+
+```json
+{
+  "name": "auto-code-quality",
+  "description": "Self-contained code quality: auto-format + auto-lint edited files",
+  "version": "1.0.0",
+  "source": "./plugins/auto-code-quality",
+  "category": "development"
+}
+```
+
+### 3. Enable in settings.json
+
+Add to your Claude Code `settings.json` under `enabledPlugins`:
+
+```json
+{
+  "enabledPlugins": {
+    "auto-code-quality@your-marketplace": true
+  }
+}
+```
+
+Replace `your-marketplace` with the name of your marketplace.
+
+## How It Works
+
+### Hook Lifecycle
+
+```
+You edit a file (Edit/Write tool)
+  │
+  ├─→ collect-edited-files.py    Appends path to temp files
+  └─→ syntax-validator.py        Validates JSON/YAML/TOML syntax immediately
+       │
+       │  ... Claude keeps working ...
+       │
+Claude stops responding (Stop event)
+  │
+  ├─→ format-on-stop.py          Reads temp file, formats each file by extension
+  └─→ lint-file.py               Reads temp file, lints each file, injects warnings
+```
+
+### Temp File Convention
+
+Edited file paths are stored in session-scoped temp files:
+- `/tmp/claude-cq-edited-{session_id}` — consumed by the formatter
+- `/tmp/claude-cq-lint-{session_id}` — consumed by the linter
+
+Both are always cleaned up after processing (even on error).
+
+### Timeouts
+
+| Hook | Timeout |
+|------|---------|
+| File collection | 3s |
+| Syntax validation | 5s |
+| Batch formatting | 15s total |
+| Batch linting | 60s total |
+| Individual tool | 10-12s each |
+
+## Conflict Warning
+
+This plugin bundles functionality that may overlap with other plugins. If you're using any of the following, **disable them** before enabling this plugin to avoid duplicate processing:
+
+- `auto-formatter` — formatting is included here
+- `auto-linter` — linting is included here
+- `code-directive` `collect-edited-files.py` hook — file collection is included here
+
+The temp file prefixes are different (`claude-cq-*` vs `claude-edited-files-*` / `claude-lint-files-*`), so enabling both won't corrupt data — but files would be formatted and linted twice.
+
+## Plugin Structure
+
+```
+auto-code-quality/
+├── .claude-plugin/
+│   └── plugin.json              # Plugin metadata
+├── hooks/
+│   └── hooks.json               # Hook registrations (PostToolUse + Stop)
+├── scripts/
+│   ├── collect-edited-files.py  # File path collector (PostToolUse)
+│   ├── syntax-validator.py      # JSON/YAML/TOML validator (PostToolUse)
+│   ├── format-on-stop.py        # Batch formatter (Stop)
+│   └── lint-file.py             # Batch linter (Stop)
+└── README.md                    # This file
+```
+
+## Requirements
+
+- Python 3.11+ (for `tomllib` support in syntax validation; older Python skips TOML)
+- Claude Code with plugin hook support

package/.devcontainer/plugins/devs-marketplace/plugins/auto-code-quality/hooks/hooks.json

@@ -0,0 +1,39 @@
+{
+	"description": "Self-contained code quality: file collection on edit, syntax validation, batch formatting + linting at stop",
+	"hooks": {
+		"PostToolUse": [
+			{
+				"matcher": "Edit|Write",
+				"hooks": [
+					{
+						"type": "command",
+						"command": "python3 ${CLAUDE_PLUGIN_ROOT}/scripts/collect-edited-files.py",
+						"timeout": 3
+					},
+					{
+						"type": "command",
+						"command": "python3 ${CLAUDE_PLUGIN_ROOT}/scripts/syntax-validator.py",
+						"timeout": 5
+					}
+				]
+			}
+		],
+		"Stop": [
+			{
+				"matcher": "",
+				"hooks": [
+					{
+						"type": "command",
+						"command": "python3 ${CLAUDE_PLUGIN_ROOT}/scripts/format-on-stop.py",
+						"timeout": 15
+					},
+					{
+						"type": "command",
+						"command": "python3 ${CLAUDE_PLUGIN_ROOT}/scripts/lint-file.py",
+						"timeout": 60
+					}
+				]
+			}
+		]
+	}
+}

package/.devcontainer/plugins/devs-marketplace/plugins/auto-code-quality/scripts/collect-edited-files.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+"""
+Collect edited file paths for batch formatting and linting at Stop.
+
+Lightweight PostToolUse hook that appends the edited file path
+to session-scoped temp files. The format and lint Stop hooks
+read these files to know which files need processing.
+
+Non-blocking: always exits 0. Runs in <10ms.
+"""
+
+import json
+import os
+import sys
+
+
+def main():
+    try:
+        input_data = json.load(sys.stdin)
+    except (json.JSONDecodeError, ValueError):
+        sys.exit(0)
+
+    session_id = input_data.get("session_id", "")
+    tool_input = input_data.get("tool_input", {})
+    file_path = tool_input.get("file_path", "")
+
+    if not file_path or not session_id:
+        sys.exit(0)
+
+    if not os.path.isfile(file_path):
+        sys.exit(0)
+
+    # Write to both formatter and linter temp files (independent pipelines)
+    # Uses "claude-cq-" prefix to avoid collision with other plugins
+    for prefix in ("claude-cq-edited", "claude-cq-lint"):
+        tmp_path = f"/tmp/{prefix}-{session_id}"
+        try:
+            with open(tmp_path, "a") as f:
+                f.write(file_path + "\n")
+        except OSError:
+            pass  # non-critical, don't block Claude
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/.devcontainer/plugins/devs-marketplace/plugins/auto-code-quality/scripts/format-on-stop.py

@@ -0,0 +1,297 @@
+#!/usr/bin/env python3
+"""
+Unified batch formatter — runs as a Stop hook.
+
+Reads file paths collected by collect-edited-files.py during the
+conversation turn, deduplicates them, and formats each based on
+extension:
+  .py / .pyi                                → Ruff format (fallback: Black)
+  .go                                       → gofmt
+  .js/.jsx/.ts/.tsx/.mjs/.cjs/.mts/.cts     → Biome check --write
+  .css/.json/.jsonc/.graphql/.gql           → Biome check --write
+  .html/.vue/.svelte/.astro                 → Biome check --write
+  .sh/.bash/.zsh/.mksh/.bats               → shfmt -w
+  .md/.markdown                             → dprint fmt
+  .yaml/.yml                                → dprint fmt
+  .toml                                     → dprint fmt
+  Dockerfile / .dockerfile                  → dprint fmt
+  .rs                                       → rustfmt
+
+Always cleans up the temp file. Always exits 0.
+"""
+
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+# ── Extension sets ──────────────────────────────────────────────────
+
+PYTHON_EXTS = {".py", ".pyi"}
+GO_EXTS = {".go"}
+BIOME_EXTS = {
+    ".js",
+    ".jsx",
+    ".ts",
+    ".tsx",
+    ".mjs",
+    ".cjs",
+    ".mts",
+    ".cts",
+    ".css",
+    ".json",
+    ".jsonc",
+    ".graphql",
+    ".gql",
+    ".html",
+    ".vue",
+    ".svelte",
+    ".astro",
+}
+SHELL_EXTS = {".sh", ".bash", ".zsh", ".mksh", ".bats"}
+DPRINT_EXTS = {".md", ".markdown", ".yaml", ".yml", ".toml"}
+RUST_EXTS = {".rs"}
+
+# ── Fallback paths ──────────────────────────────────────────────────
+
+BLACK_PATH_FALLBACK = "/usr/local/py-utils/bin/black"
+GOFMT_PATH_FALLBACK = "/usr/local/go/bin/gofmt"
+DPRINT_CONFIG = "/usr/local/share/dprint/dprint.json"
+
+# ── Tool resolution ─────────────────────────────────────────────────
+
+
+def _resolve_tool(name: str, fallback: str = "") -> str | None:
+    """Find tool via PATH first, fall back to hardcoded path."""
+    try:
+        result = subprocess.run(["which", name], capture_output=True, text=True)
+        if result.returncode == 0:
+            return result.stdout.strip()
+    except Exception:
+        pass
+    if fallback and os.path.exists(fallback):
+        return fallback
+    return None
+
+
+def find_tool_upward(file_path: str, tool_name: str) -> str | None:
+    """Walk up from file directory looking for node_modules/.bin/<tool>."""
+    current = Path(file_path).parent
+    for _ in range(20):
+        candidate = current / "node_modules" / ".bin" / tool_name
+        if candidate.is_file():
+            return str(candidate)
+        parent = current.parent
+        if parent == current:
+            break
+        current = parent
+    return None
+
+
+def find_global_tool(tool_name: str) -> str | None:
+    """Check if tool is available globally."""
+    try:
+        result = subprocess.run(
+            ["which", tool_name],
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+    except Exception:
+        pass
+    return None
+
+
+def find_biome(file_path: str) -> str | None:
+    """Find biome binary: project-local first, then global."""
+    local = find_tool_upward(file_path, "biome")
+    if local:
+        return local
+    return find_global_tool("biome")
+
+
+# ── Formatters ──────────────────────────────────────────────────────
+
+
+def format_python(file_path: str) -> None:
+    """Format with Ruff (preferred) or Black (fallback)."""
+    ruff = _resolve_tool("ruff")
+    if ruff:
+        try:
+            subprocess.run(
+                [ruff, "format", "--quiet", file_path],
+                capture_output=True,
+                timeout=10,
+            )
+            return
+        except (subprocess.TimeoutExpired, OSError):
+            pass
+
+    # Fallback to Black
+    black = _resolve_tool("black", BLACK_PATH_FALLBACK)
+    if not black:
+        return
+    try:
+        subprocess.run(
+            [black, "--quiet", file_path],
+            capture_output=True,
+            timeout=10,
+        )
+    except (subprocess.TimeoutExpired, OSError):
+        pass
+
+
+def format_go(file_path: str) -> None:
+    """Format with gofmt."""
+    gofmt = _resolve_tool("gofmt", GOFMT_PATH_FALLBACK)
+    if not gofmt:
+        return
+    try:
+        subprocess.run(
+            [gofmt, "-w", file_path],
+            capture_output=True,
+            timeout=10,
+        )
+    except (subprocess.TimeoutExpired, OSError):
+        pass
+
+
+def format_biome(file_path: str) -> None:
+    """Format with Biome in safe mode (no --unsafe)."""
+    biome = find_biome(file_path)
+    if not biome:
+        return
+    try:
+        subprocess.run(
+            [biome, "check", "--write", file_path],
+            capture_output=True,
+            timeout=12,
+        )
+    except (subprocess.TimeoutExpired, OSError):
+        pass
+
+
+def format_shell(file_path: str) -> None:
+    """Format with shfmt."""
+    shfmt = _resolve_tool("shfmt")
+    if not shfmt:
+        return
+    try:
+        subprocess.run(
+            [shfmt, "-w", file_path],
+            capture_output=True,
+            timeout=10,
+        )
+    except (subprocess.TimeoutExpired, OSError):
+        pass
+
+
+def format_dprint(file_path: str) -> None:
+    """Format with dprint using the global config."""
+    dprint = _resolve_tool("dprint")
+    if not dprint:
+        return
+    if not os.path.isfile(DPRINT_CONFIG):
+        return
+    try:
+        subprocess.run(
+            [dprint, "fmt", "--config", DPRINT_CONFIG, file_path],
+            capture_output=True,
+            timeout=10,
+        )
+    except (subprocess.TimeoutExpired, OSError):
+        pass
+
+
+def format_rust(file_path: str) -> None:
+    """Format with rustfmt (conditional — only if installed)."""
+    rustfmt = _resolve_tool("rustfmt")
+    if not rustfmt:
+        return
+    try:
+        subprocess.run(
+            [rustfmt, file_path],
+            capture_output=True,
+            timeout=10,
+        )
+    except (subprocess.TimeoutExpired, OSError):
+        pass
+
+
+# ── Dispatch ────────────────────────────────────────────────────────
+
+
+def format_file(file_path: str) -> None:
+    """Dispatch to the correct formatter based on extension / filename."""
+    path = Path(file_path)
+    ext = path.suffix.lower()
+    name = path.name
+
+    if ext in PYTHON_EXTS:
+        format_python(file_path)
+    elif ext in GO_EXTS:
+        format_go(file_path)
+    elif ext in BIOME_EXTS:
+        format_biome(file_path)
+    elif ext in SHELL_EXTS:
+        format_shell(file_path)
+    elif ext in DPRINT_EXTS:
+        format_dprint(file_path)
+    elif ext in RUST_EXTS:
+        format_rust(file_path)
+    elif name == "Dockerfile" or ext == ".dockerfile":
+        format_dprint(file_path)
+
+
+# ── Main ────────────────────────────────────────────────────────────
+
+
+def main():
+    try:
+        input_data = json.load(sys.stdin)
+    except (json.JSONDecodeError, ValueError):
+        sys.exit(0)
+
+    # Prevent infinite loops if Stop hook triggers another stop
+    if input_data.get("stop_hook_active"):
+        sys.exit(0)
+
+    session_id = input_data.get("session_id", "")
+    if not session_id:
+        sys.exit(0)
+
+    tmp_path = f"/tmp/claude-cq-edited-{session_id}"
+
+    try:
+        with open(tmp_path) as f:
+            raw_paths = f.read().splitlines()
+    except FileNotFoundError:
+        sys.exit(0)
+    except OSError:
+        sys.exit(0)
+    finally:
+        # Always clean up the temp file
+        try:
+            os.unlink(tmp_path)
+        except OSError:
+            pass
+
+    # Deduplicate while preserving order, filter to existing files
+    seen: set[str] = set()
+    paths: list[str] = []
+    for p in raw_paths:
+        p = p.strip()
+        if p and p not in seen and os.path.isfile(p):
+            seen.add(p)
+            paths.append(p)
+
+    for path in paths:
+        format_file(path)
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()