# Check Scripts

> Run a phased scripts audit in scripts/*.py: validate Script overrides (init/title/show) first, then verify ui() output compatibility with run() or process() parameters.

- Skill: `vladmandic/check-scripts` (Agent Skill)
- Install (CLI): `npx skillmds@latest add vladmandic/check-scripts`
- Raw SKILL.md: https://api.skillmd.com/api/skills/vladmandic/check-scripts/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Security
- Author: vladmandic (https://skillmd.com/u/vladmandic)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/vladmandic/check-scripts

---


# Check Script Class Contracts

Audit all Python scripts in `scripts/*.py` and validate that script class overrides and UI-to-execution parameter contracts are correct.

## When To Use

- New or changed files were added under `scripts/*.py`
- A script crashes when selected or executed from UI
- A script UI was changed and runtime args no longer match
- You want a pre-PR quality gate for script API compatibility

## Guidance

- Consult `.github/instructions/core.instructions.md` for relevant core runtime guidance before proceeding.

## Scope

Primary audit scope:

- `scripts/*.py`

Contract references:

- `modules/scripts_manager.py` (`Script` base class contracts for `title`, `show`, `ui`, `run`, `process`)
- `modules/scripts_postprocessing.py` (`ScriptPostprocessing` contracts for `ui` and `process`)

## Required Checks

### A. Standard Overrides: `__init__`, `title`, `show`

For each class in `scripts/*.py` that subclasses `scripts.Script` or `scripts_manager.Script`:

1. `title`:
- method exists
- callable signature is valid
- returns non-empty string value

2. `show`:
- method exists
- signature is compatible with script runner usage (`show(is_img2img)` or permissive `*args/**kwargs`)
- return behavior is compatible (`bool` or `scripts.AlwaysVisible` / equivalent)

3. `__init__` (if overridden):
- does not require mandatory constructor args that would break loader instantiation
- avoids side effects that require runtime-only globals at import time
- leaves class in a usable state before `ui()`/`run()`/`process()` are called

Notes:
- `__init__` is optional; do not fail scripts that rely on inherited constructor.
- For dynamic patterns, flag as warning with rationale instead of hard fail.

### B. `ui()` Output vs `run()`/`process()` Parameters

For each script class:

1. Determine execution target:
- Prefer `run()` if present for generation scripts
- Use `process()` if present and `run()` is absent or script is postprocessing-oriented

2. Compare `ui()` output shape to target method parameter expectations:
- `ui()` list/tuple output count should match target positional argument capacity after the first processing arg (`p` or `pp`), unless target uses `*args`
- if target is strict positional (no `*args`/`**kwargs`), detect missing/extra UI values
- if target uses keyword-driven processing, ensure UI dict keys map to accepted params or `**kwargs`

3. Validate ordering assumptions:
- UI control order should align with positional parameter order when positional binding is used
- detect obvious drift when new UI control was added but method signature was not updated

4. Validate optionality/defaults:
- required target parameters should be satisfiable by UI outputs
- defaulted target params are acceptable even if UI omits them

### C. Runner Compatibility

Confirm script methods align with runner expectations in `modules/scripts_manager.py`:

- `ui()` return type is compatible with runner collection (`list/tuple` or recognized mapping pattern where used)
- `run()`/`process()` receive args in expected form from runner slices
- no obvious mismatch between `args_from/args_to` assumptions and script method arity

For postprocessing-style scripts in `scripts/*.py`:

- verify compatibility with `modules/scripts_postprocessing.py` conventions (`ui()` list/dict, `process(pp, *args, **kwargs)`)

## Procedure

1. Enumerate all classes in `scripts/*.py` and classify by base class type.
2. For each generation script class, validate `title`, `show`, optional `__init__`, and `ui` -> `run/process` contracts.
3. For each postprocessing script class under `scripts/*.py`, validate `ui` -> `process` mapping semantics.
4. Cross-check ambiguous cases against script runner behavior from `modules/scripts_manager.py` and `modules/scripts_postprocessing.py`.
5. Report concrete mismatches with minimal fixes.

## Reporting Format

Return findings by severity:

1. Blocking script contract failures
2. Runtime- likely arg/arity mismatches
3. Signature/type compatibility warnings
4. Style/consistency improvements

For each finding include:

- script file
- class name
- failing contract area (`init`, `title`, `show`, `ui->run`, `ui->process`)
- mismatch summary
- minimal fix

Also include summary counts:

- total `scripts/*.py` files checked
- total script classes checked
- classes with `run` contract checked
- classes with `process` contract checked
- override issues found (`init/title/show`)

## Pass Criteria

A full pass requires all of the following across audited `scripts/*.py` classes:

- `title` and `show` overrides are valid and runner-compatible for generation scripts
- overridden `__init__` methods are safely instantiable
- `ui()` output contracts are compatible with `run()` or `process()` args
- no blocking arity/signature mismatch remains

If a class uses runtime-determined argument mapping or dynamic method dispatch that cannot be proven statically, mark as conditional pass with explicit runtime validation recommendation.