Przejdź do treści
Biblioteka skilli
Programowanie · Automatyzacja

plankton-code-quality

/plankton-code-quality

Wymusza formatowanie, lint i automatyczne poprawki przy każdym zapisie pliku przez hooki Plankton, z naprawami wspieranymi przez Nemo.

Repozytorium
Nemo-Cli ↗
Licencja
Apache-2.0
Ostatnia zmiana repozytorium
05.11.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 05.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

Co robi i kiedy

Wymusza formatowanie, lint i automatyczne poprawki przy każdym zapisie pliku przez hooki Plankton, z naprawami wspieranymi przez Nemo.

Oryginalny opis (EN)

Write-time code quality enforcement using Plankton — auto-formatting, linting, and Nemo-powered fixes on every file edit via hooks. Use when setting up write-time formatting, linting, or auto-fix hooks on file edits.

Jak działa

  1. When to Use
  2. How It Works
  3. Setup
  4. Pairing with ECC
  5. Configuration Reference
  6. Environment Overrides
  7. References
  8. ECC v1.8 Additions
Sekcje z nagłówków SKILL.md, w oryginale · 236 linii, 1 142 słów
Podgląd SKILL.md
---
name: plankton-code-quality
description: "Write-time code quality enforcement using Plankton — auto-formatting, linting, and Nemo-powered fixes on every file edit via hooks. Use when setting up write-time formatting, linting, or auto-fix hooks on file edits."
metadata:
  origin: community
---

# Plankton Code Quality Skill

Integration reference for Plankton (credit: @alxfazio), a write-time code quality enforcement system for Nemo Code. Plankton runs formatters and linters on every file edit via PostToolUse hooks, then spawns Nemo subprocesses to fix violations the agent didn't catch.

## When to Use

- You want automatic formatting and linting on every file edit (not just at commit time)
- You need defense against agents modifying linter configs to pass instead of fixing code
- You want tiered model routing for fixes (Haiku for simple style, Sonnet for logic, Opus for types)
- You work with multiple languages (Python, TypeScript, Shell, YAML, JSON, TOML, Markdown, Dockerfile)

## How It Works

### Three-Phase Architecture

Every time Nemo Code edits or writes a file, Plankton's `multi_linter.sh` PostToolUse hook runs:

```
Phase 1: Auto-Format (Silent)
├─ Runs formatters (ruff format, biome, shfmt, taplo, markdownlint)
├─ Fixes 40-50% of issues silently
└─ No output to main agent

Phase 2: Collect Violations (JSON)
├─ Runs linters and collects unfixable violations
├─ Returns structured JSON: {line, column, code, message, linter}
└─ Still no output to main agent

Phase 3: Delegate + Verify
├─ Spawns nemo -p subprocess with violations JSON
├─ Routes to model tier based on violation complexity:
│   ├─ Haiku: formatting, imports, style (E/W/F codes) — 120s timeout
│   ├─ Sonnet: complexity, refactoring (C901, PLR codes) — 300s timeout
│   └─ Opus: type system, deep reasoning (unresolved-attribute) — 600s timeout
├─ Re-runs Phase 1+2 to verify fixes
└─ Exit 0 if clean, Exit 2 if violations remain (reported to main agent)
```

### What the Main Agent Sees

| Scenario                           | Agent sees                     | Hook exit |
| ---------------------------------- | ------------------------------ | --------- |
| No violations                      | Nothing                        | 0         |
| All fixed by subprocess            | Nothing                        | 0         |
| Violations remain after subprocess | `[hook] N violation(s) remain` | 2         |
| Advisory (duplicates, old tooling) | `[hook:advisory] ...`          | 0         |

The main agent only sees issues the subprocess couldn't fix. Most quality problems are resolved transparently.

### Config Protection (Defense Against Rule-Gaming)

LLMs will modify `.ruff.toml` or `biome.json` to disable rules rather than fix code. Plankton blocks this with three layers:

1. **PreToolUse hook** — `protect_linter_configs.sh` blocks edits to all linter configs before they happen
2. **Stop hook** — `stop_config_guardian.sh` detects config changes via `git diff` at session end
3. **Protected files list** — `.ruff.toml`, `biome.json`, `.shellcheckrc`, `.yamllint`, `.hadolint.yaml`, and more

### Package Manager Enforcement

A PreToolUse hook on Bash blocks legacy package managers:

- `pip`, `pip3`, `poetry`, `pipenv` → Blocked (use `uv`)
- `npm`, `yarn`, `pnpm` → Blocked (use `bun`)
- Allowed exceptions: `npm audit`, `npm view`, `npm publish`

## Setup

### Quick Start

> **Note:** Plankton requires manual installation from its repository. Review the code before installing.

```bash
# Install core dependencies
brew install jaq ruff uv

# Install Python linters
uv sync --all-extras

# Start Nemo Code — hooks activate automatically
nemo
```

No install command, no plugin config. The hooks in `.nemo/settings.json` are picked up automatically when you run Nemo Code in the Plankton directory.

### Per-Project Integration

To use Plankton hooks in your own project:

1. Copy `.nemo/hooks/` directory to your project
2. Copy `.nemo/settings.json` hook configuration
3. Copy linter config files (`.ruff.toml`, `biome.json`, etc.)
4. Install the linters for your languages

### Language-Specific Dependencies

| Language      | Required               | Optional                                                 |
| ------------- | ---------------------- | -------------------------------------------------------- |
| Python        | `ruff`, `uv`           | `ty` (types), `vulture` (dead code), `bandit` (security) |
| TypeScript/JS | `biome`                | `oxlint`, `semgrep`, `knip` (dead exports)               |
| Shell         | `shellcheck`, `shfmt`  | —                                                        |
| YAML          | `yamllint`             | —                                                        |
| Markdown      | `markdownlint-cli2`    | —                                                        |
| Dockerfile    | `hadolint` (>= 2.12.0) | —                                                        |
| TOML          | `taplo`                | —                                                        |
| JSON          | `jaq`                  | —                                                        |

## Pairing with ECC

### Complementary, Not Overlapping

| Concern                  | ECC                                  | Plankton                                           |
| ------------------------ | ------------------------------------ | -------------------------------------------------- |
| Code quality enforcement | PostToolUse hooks (Prettier, tsc)    | PostToolUse hooks (20+ linters + subprocess fixes) |
| Security scanning        | AgentShield, security-reviewer agent | Bandit (Python), Semgrep (TypeScript)              |
| Config protection        | —                                    | PreToolUse blocks + Stop hook detection            |
| Package manager          | Detection + setup                    | Enforcement (blocks legacy PMs)                    |
| CI integration           | —                                    | Pre-commit hooks for git                           |
| Model routing            | Manual (`/model opus`)               | Automatic (violation complexity → tier)            |

### Recommended Combination

1. Install ECC as your plugin (agents, skills, commands, rules)
2. Add Plankton hooks for write-time quality enforcement
3. Use AgentShield for security audits
4. Use ECC's verification-loop as a final gate before PRs

### Avoiding Hook Conflicts

If running both ECC and Plankton hooks:

- ECC's Prettier hook and Plankton's biome formatter may conflict on JS/TS files
- Resolution: disable ECC's Prettier PostToolUse hook when using Plankton (Plankton's biome is more comprehensive)
- Both can coexist on different file types (ECC handles what Plankton doesn't cover)

## Configuration Reference

Plankton's `.nemo/hooks/config.json` controls all behavior:

```json
{
  "languages": {
    "python": true,
    "shell": true,
    "yaml": true,
    "json": true,
    "toml": true,
    "dockerfile": true,
    "markdown": true,
    "typescript": {
      "enabled": true,
      "js_runtime": "auto",
      "biome_nursery": "warn",
      "semgrep": true
    }
  },
  "phases": {
    "auto_format": true,
    "subprocess_delegation": true
  },
  "subprocess": {
    "tiers": {
      "haiku": { "timeout": 120, "max_turns": 10 },
      "sonnet": { "timeout": 300, "max_turns": 10 },
      "opus": { "timeout": 600, "max_turns": 15 }
    },
    "volume_threshold": 5
  }
}
```

**Key settings:**

- Disable languages you don't use to speed up hooks
- `volume_threshold` — violations > this count auto-escalate to a higher model tier
- `subprocess_delegation: false` — skip Phase 3 entirely (just report violations)

## Environment Overrides

| Variable                    | Purpose                                  |
| --------------------------- | ---------------------------------------- |
| `HOOK_SKIP_SUBPROCESS=1`    | Skip Phase 3, report violations directly |
| `HOOK_SUBPROCESS_TIMEOUT=N` | Override tier timeout                    |
| `HOOK_DEBUG_MODEL=1`        | Log model selection decisions            |
| `HOOK_SKIP_PM=1`            | Bypass package manager enforcement       |

## References

- Plankton (credit: @alxfazio)
- Plankton REFERENCE.md — Full architecture documentation (credit: @alxfazio)
- Plankton SETUP.md — Detailed installation guide (credit: @alxfazio)

## ECC v1.8 Additions

### Copyable Hook Profile

Set strict quality behavior:

```bash
export ECC_HOOK_PROFILE=strict
export ECC_QUALITY_GATE_FIX=true
export ECC_QUALITY_GATE_STRICT=true
```

### Language Gate Table

- TypeScript/JavaScript: Biome preferred, Prettier fallback
- Python: Ruff format/check
- Go: gofmt

### Config Tamper Guard

During quality enforcement, flag changes to config files in same iteration:

- `biome.json`, `.eslintrc*`, `prettier.config*`, `tsconfig.json`, `pyproject.toml`

If config is changed to suppress violations, require explicit review before merge.

### CI Integration Pattern

Use the same commands in CI as local hooks:

1. run formatter checks
2. run lint/type checks
3. fail fast on strict mode
4. publish remediation summary

### Health Metrics

Track:

- edits flagged by gates
- average remediation time
- repeat violations by category
- merge blocks due to gate failures

Wersje

RepozytoriumWynikLicencja
Ta strona · SHRIJANAGAIN/Nemo-Cli100Apache-2.0
affaan-m/ECC100MIT
ginaservice/ginaservice-skills100MIT
nguyentrunghieutcu/ctxora-engine100MIT
affaan-m/ECC96MIT
aaione/everything-claude-code-zh96MIT
mturac/everything-openai-codex96MIT

Migawka bazy z 13.11.2026 · wersja paczki d940fb8d2c86 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100python-code-quality
    Uruchamia kontrole jakości kodu, linting, formatowanie i sprawdzanie typów w kodzie Pythona Agent Framework oraz naprawia błędy lintu i problemy CI.
  • 100python-code-quality
    Dba o jakość kodu Python z ruff i ty: linting, formatowanie, sprawdzanie typów i styl kodu.
  • 100quality-check
    Waliduje jakość kodu w Python, JS/TS, Shell i SQL z automatycznym wykrywaniem języka: formatowanie, linting, sprawdzanie typów i analiza złożoności.
  • 100code-linting
    Konfiguruje, naprawia i stroi linting oraz formatowanie projektu w dowolnym języku, w tym pre-commit hooki, hałaśliwe lub nieudane zadania lintu i ujednolicanie bazy kodu.
  • 100lint
    Prowadzi lintowanie i pilnuje standardów kodu: ESLint, Prettier, Biome, Ruff i golangci-lint, własne reguły, automatyczne poprawki, hooki pre-commit i egzekwowanie stylu.
  • 100git-hooks-husky-pre-commit-lintstaged
    Wymusza lintowanie, formatowanie i testy jednostkowe przed commitem przez Husky i lint-staged.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.