av-module-maker

KO | EN

gitlite — search

#vue #python #command-line #typescript #nextjs #security #react #bash #monitoring #c

av-module-maker

(★ 9)

AI driven module/plugins for qsys/extron/crestron

File Explorer

ZIP Download

- marketplace.json
- plugin.json
- - SIMPLSHARP_API_CORPUS.md
  - SIMPLSHARP_COMPILATION.md
  - SIMPLSHARP_OVERVIEW.md
- - QSYS_CONSTRAINTS.md
  - QSYS_DOC_INDEX.md
  - QSYS_PATTERNS.md
- AUTHOR_POLICY.md
- RALPH_TODO.md
- - README.md
  - simplplus_build.py
  - simplsharp_build.py
- - compile.py
- - board.py
  - module-loop-prompt.md
  - ralph-module-loop.sh
  - render_pass.py
  - status.py
.gitattributes
.gitignore
LICENSE
README.md

# Use via CDN

jsDelivr

jsDelivr serves any public GitHub repository as a CDN with zero setup. Pick a version and a file to get a ready-to-paste link and snippet.

Version

File

Link

Example

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

A Claude Code plugin for scaffolding, compiling, and revising control-system modules —
Q-SYS plugins and Crestron SIMPL+ and SIMPL# modules today, with Crestron SIMPL# Pro
and Extron Global Scripter support in the works.

Works from any Claude Code session in any project — no need to `cd` into this repo.

## Install

From any Claude Code terminal session:

```
/plugin marketplace add shorty456132/av-module-maker
/plugin install module-maker@module-maker
```

The first command registers this repo as a plugin marketplace (Claude Code reads
`.claude-plugin/marketplace.json` from the repo root); the second installs the plugin.
You can also run `/plugin` with no arguments to add the marketplace and install from the
interactive menu. The `/module-maker:*` skill commands run in the terminal CLI.

## Requirements

Installing the plugin needs only Claude Code. **Compiling** the modules the skills
produce needs the host toolchains below — install only the ones for the platforms you
target. Software used to *operate* finished modules (the SIMPL Windows GUI, Visual
Studio) is **not** needed to compile.

**All platforms**
- **Python 3.13** on `PATH` — the `compile`/`build` scripts under `scripts/` are Python.

**Crestron SIMPL+**
- **SIMPL+ Cross Compiler (`SPlusCC.exe`)** — install via the **Crestron Master
  Installer** (Windows). Default path
  `C:\Program Files (x86)\Crestron\Simpl\SPlusCC.exe`; override with `--compiler=<path>`
  or the `SPLUSCC` environment variable. The SIMPL Windows GUI is not required.

**Crestron SIMPL#**
- **.NET SDK** (`dotnet` / MSBuild) — builds the `.clz` (targets `net47`, 4-Series).
  The `Crestron.SimplSharp.SDK.Library` NuGet package restores automatically via
  `dotnet` — no separate install. **Visual Studio is not required.**
- **`SPlusCC.exe`** (as above) — SIMPL# also compiles a `.usp` wrapper.

**Crestron SIMPL# Pro** (WIP)
- **.NET SDK** (`dotnet` / MSBuild) — builds the `.cpz` (targets `net47`, 4-Series and
  VC-4). The `Crestron.SimplSharp.SDK.*` NuGet packages restore automatically via
  `dotnet` — no separate install. **Visual Studio is not required.**

## Layout

Skills, reference docs, and scripts are grouped by platform:

```
skills/qsys/…        reference/qsys/…        scripts/qsys/…
skills/crestron/…    reference/crestron/…    scripts/crestron/…
```

Each platform folder is registered as a skill root in `.claude-plugin/plugin.json`
(`"skills": ["./skills/qsys/", "./skills/crestron/"]`), since plugin skill discovery
is not recursive.

Q-SYS help content is **not** bundled in this repo. `reference/qsys/` holds the
hand-authored `QSYS_PATTERNS.md` and `QSYS_CONSTRAINTS.md` plus `QSYS_DOC_INDEX.md`,
a topic→URL map of QSC's official help pages. The skills look a topic up in that index
and fetch the live page on demand, so the docs stay current and no third-party
material is redistributed.

## Skills

**Q-SYS** (ready):
- `/module-maker:create-plugin <description>` — scaffold a complete Q-SYS plugin (all
  modular `.lua` files) from a device description.
- `/module-maker:compile <plugin-directory>` — resolve `--[[ #include ]]` directives and
  produce a single `.qplug` file, with a version-bump prompt.
- `/module-maker:plugin-revision <plugin-directory>` — review and revise an existing Q-SYS
  plugin's Lua, then recompile.

**Crestron SIMPL+** (ready):
- `/module-maker:simplplus-create <description>` — scaffold a Crestron SIMPL+ module
  (`.usp`) from a device description, with correct INPUT/OUTPUT signal structure, event
  handlers, and automatic compile verification via the SIMPL+ Cross Compiler.
- `/module-maker:simplplus-revise <module-path>` — review and revise an existing SIMPL+
  module against the SIMPL+ constraints, then recompile clean.

**Crestron SIMPL#** (ready):
- `/module-maker:simplsharp-create <description>` — scaffold a Crestron SIMPL# library
  (`.clz`) in C# that exposes signals to SIMPL Windows, then generate its SIMPL+ `.usp`
  wrapper and compile both (`dotnet build` → stage `.clz` → SIMPL+ Cross Compiler).
- `/module-maker:simplsharp-revise <project-path>` — review and revise an existing SIMPL#
  library against the SIMPL# constraints, then rebuild.

**Crestron SIMPL# Pro** (WIP — stubs scaffolded): `simplsharp-pro-create` /
`simplsharp-pro-revise` — scaffold and revise a SIMPL# Pro program (`.cpz`) for 4-Series
appliances and VC-4.

## Ralph loop (unattended module builds)

For large or overnight builds, a create skill can emit a `TODO.md` kanban board
into the module directory and hand off to a **raw Ralph loop** —
`scripts/ralph/ralph-module-loop.sh`, which re-runs `claude -p` with a fixed
prompt so **every pass gets a fresh context window**. The board (`📋 Next Up /
🔄 In Progress / ✅ Done / 🚫 Blocked`) plus the files on disk are the loop's only
memory (no git); it advances one card per pass and stops when the board's
`_Status:` line reads `done` or `blocked`. Ask for a "Ralph loop" or "TODO.md
build" to use it.

```
# from Git Bash on Windows:
scripts/ralph/ralph-module-loop.sh ./My-Plugin/
```

The board format and per-pass protocol are specified in
`reference/RALPH_TODO.md`; the deterministic board engine is
`scripts/ralph/board.py` (unit-tested under `scripts/ralph/tests/`). This is
distinct from the `/ralph-loop` plugin, which keeps a single accumulating
session rather than fresh context per pass.

### Watching a run

Each run keeps its state in `<module-dir>/.ralph/` (git-ignored), so a build you
launched in one terminal — or in the background hours ago — can be inspected from
anywhere without touching the loop:

```
python scripts/ralph/status.py show ./My-Plugin/   # pass, card, progress, spend
tail -f ./My-Plugin/.ralph/run.log                 # the live narration
cat ./My-Plugin/.ralph/REPORT.md                   # written on every exit path
touch ./My-Plugin/.ralph/STOP                      # stop cleanly — no PID hunt
```

Each pass narrates itself as it works (one line per tool call, then a token/cost
line), because `claude -p` runs with `--output-format stream-json` piped through
`scripts/ralph/render_pass.py`. The raw stream for pass *N* is kept at
`.ralph/logs/pass-NN.jsonl`, and cumulative tokens and dollars accumulate in
`.ralph/status.json`.

The loop's exit code says how it ended: `0` done · `1` max passes (or run budget)
· `2` no `TODO.md` · `3` blocked · `4` not converging · `5` stopped · `6` pass
timeout. Knobs, all optional: `STALL_MAX` (2), `PASS_TIMEOUT` (900s),
`IDLE_WARN` (300s), `PASS_BUDGET_USD`, `RUN_BUDGET_USD`.

## Roadmap

- **Now**: Q-SYS plugin creation, compilation, and revision; Crestron SIMPL+ and SIMPL#
  module creation and revision with compile verification.
- **In progress**: Crestron SIMPL# Pro (`.cpz`) module creation — folder structure and
  skill stubs are in place; reference docs and implementation to follow.
- **Planned**: Extron Global Scripter module creation, following the same
  `skills/<platform>/` + `reference/<platform>/` convention.

## License

MIT — see `LICENSE`.

av-module-maker

Owner Repos

File Explorer

# Use via CDN

Was this content helpful?

Recent Feedback

av-module-maker

Owner Repos

File Explorer

# Use via CDN

Was this content helpful?

Recent Feedback

Download README