wicked-studio 0.4.14 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (8) hide show
  1. package/README.md +125 -128
  2. package/dist/assets/index-BmXt63Ij.js +537 -0
  3. package/dist/assets/index-eso7X_3n.css +32 -0
  4. package/dist/index.html +2 -2
  5. package/dist/testid-inventory.json +411 -150
  6. package/package.json +2 -2
  7. package/dist/assets/index-CDWyxcSj.js +0 -537
  8. package/dist/assets/index-Dz6mXrD5.css +0 -32
package/README.md CHANGED
@@ -2,166 +2,163 @@
2
2
 
3
3
  > [![npm](https://img.shields.io/npm/v/wicked-studio)](https://www.npmjs.com/package/wicked-studio) · [![CI](https://github.com/mikeparcewski/wicked-studio/actions/workflows/ci.yml/badge.svg)](https://github.com/mikeparcewski/wicked-studio/actions/workflows/ci.yml) · [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
4
4
 
5
- **The coder-facing skin of the wicked experience plane.** A React SPA that is a *pure HTTP/WS
6
- client* of the [wicked-crew](https://github.com/mikeparcewski/wicked-crew) daemon: launch and
7
- steer governed agent runs, answer human gates, watch live CoreEvent streams, browse projects,
8
- repo intelligence, evidence, coverage, and the decisions ledger — everything the daemon exposes
9
- on `/api/v1` and `/ws`, and nothing else.
10
-
11
- ## What the skin surfaces (0.4.x)
12
-
13
- Every capability below is a real `/api/v1` or `/ws` wire — no invented routes — verified by a
14
- 21-scenario functional campaign against an isolated daemon (21/21 PASS, evidence-graded;
15
- `estate-review/STUDIO-CAMPAIGN.md`). Legs the campaign could only prove over the wire rather
16
- than through the UI are marked as such below.
17
-
18
- - **Projects** — create/rename/archive/restore, attach and detach members (repos, runs, chats,
19
- docs), a merged activity feed with a prompt inbox, a per-project dashboard, and a four-mode
20
- project shell (chat / build / document / video) with deep-linkable routes (`/p/:id/…`).
21
- - **Repo intelligence** — register a local path or clone from a URL; either launches a governed
22
- onboarding run (`index` → `annotate`, two tool units) that builds the repo's code graph. Then:
23
- graph view with ego-focus navigation, **blast radius** for any symbol, hotspots, the domain
24
- graph + coverage view, and a requirements browser with operator overrides (PATCH
25
- title/notes/status/risk).
26
- - **Governed runs** — the composer (Ask / Balanced / Autonomous, seat selection, repo binding,
27
- PR delivery), run list/detail/timeline with event backfill on reload, **HITL steering gates**
28
- (approve / approve-with-steer / reject, plus keyboard batch triage), elicitation prompts,
29
- durable pre-gate guidance notes, and the lifecycle verbs the UI wires today: cancel, inject
30
- a message, unarchive, retry lineage. (Resume and archive exist as typed client wires,
31
- campaign-verified over the API — the UI affordances are a filed gap, not yet shipped.)
32
- - **Evidence** — per-unit transcripts, the worktree file & diff viewer, and one-click
33
- **evidence bundle download** for any run. The skin surfaces the gates; it never grades.
34
- - **Group chat** — fan one question out to your whole warm CLI roster and watch each seat
35
- answer side by side.
36
- - **Governed PTY terminals** — real terminals (xterm over `/ws/terminals/:id`), including the
37
- seat sign-in flow from settings.
38
- - **Workflow builder** — inspect and create WorkflowDefs (phases, gates, validation) and their
39
- inline tool scripts, then launch runs against them.
40
- - **Governance** — policies, conformance rules (with facet preview), the decisions/claims
41
- ledger, and the audit view.
42
- - **Settings** — daemon settings plus `studio.*` namespaced keys: appearance/theme (including
43
- brand-learn), notifications, composer preferences.
44
- - **Document & Video modes** — the merged creator surface, riding crew's proxied interactive
45
- bridge under `/api/v1/projects/:id/interactive/*`.
46
- - **Command palette + deep links** — Cmd+K verbs (open terminal, answer prompts), bookmarkable
47
- routes throughout, desktop gate notifications.
5
+ **The cockpit for AI coding agents you can actually trust.** wicked-studio is a browser UI for
6
+ running coding-agent CLIs (Claude Code, Codex, Antigravity, and more) as *governed* workers:
7
+ you give an intent, the agents do the work behind verification gates, and you approve the
8
+ decisions that matter — with the evidence behind every "done" one click away.
9
+
10
+ It's the human surface of the [wicked](https://github.com/mikeparcewski/wicked-crew) platform.
11
+ The agents run headless in the background; studio is where you point them at your repos, watch
12
+ them work in real time, unblock them when they need a human, and see what actually happened.
13
+
14
+ ---
15
+
16
+ ## Why you'd want it
17
+
18
+ Coding agents are fast but unsupervised — they assert "done," grade their own work, and bury the
19
+ reasoning in a scrollback you'll never read. wicked-studio flips that:
20
+
21
+ - **Direct, don't babysit.** Launch runs across many repos and projects at once, then let them
22
+ work. Attention comes to *you* when a run hits a gate — you don't sit watching one terminal.
23
+ - **Approve what matters.** Human-in-the-loop gates surface the real decisions (approve, approve
24
+ with a steer, or reject) — with keyboard batch triage when several pile up.
25
+ - **"Done" is proven, not claimed.** The evaluator is never the creator. Every run leaves
26
+ transcripts, diffs, and a downloadable evidence bundle; studio shows you the gate outcomes, it
27
+ never grades the work itself.
28
+ - **Understand the code first.** Onboard a repo and studio builds its graph — then blast-radius
29
+ for any symbol, hotspots, the domain/requirements view, and a searchable map of what calls what.
30
+
31
+ ## What you can do
32
+
33
+ - **Run governed agents on your repos** — register a local path or clone a URL; studio builds the
34
+ code graph, then you launch runs (ask / balanced / autonomous), pick which agent seats join, and
35
+ bind a repo with optional PR delivery.
36
+ - **Steer runs live** — a real-time timeline of every run, human gates with approve / steer /
37
+ reject, elicitation prompts, pre-gate guidance notes, and lifecycle controls (cancel, inject a
38
+ message, retry).
39
+ - **See the evidence** — per-step transcripts, a worktree file + diff viewer, and one-click
40
+ evidence-bundle download for any run.
41
+ - **Explore your codebase** — graph view with focus navigation, blast radius, hotspots, and the
42
+ domain graph with coverage.
43
+ - **Ask your whole model roster at once** — fan one question out to every warm CLI and compare the
44
+ answers side by side.
45
+ - **Govern the work** — author steering rules and policies, browse the decisions ledger, and review
46
+ what the platform has learned about your repos.
47
+ - **Work in projects** — group repos, runs, chats, and docs; a merged activity feed and dashboard
48
+ per project; deep-linkable routes throughout.
49
+ - **Plus** governed terminals, a Cmd+K command palette, document & video creation modes, and
50
+ desktop notifications when a run needs you.
51
+
52
+ ---
53
+
54
+ ## Get started
55
+
56
+ Studio ships **inside** wicked-crew — one command gives you the API, the engine, and this UI on a
57
+ single port:
48
58
 
59
+ ```sh
60
+ npx wicked-crew serve
61
+ # then open the URL it prints (default http://127.0.0.1:7701)
49
62
  ```
50
- ┌─────────────────────┐ HTTP /api/v1 + WS /ws ┌──────────────────────┐
51
- │ wicked-studio │ ───────────────────────────────────────▶ │ wicked-crew daemon │
52
- │ (this repo, SPA) │ ◀─────────────────────────────────────── │ (control plane: │
53
- │ the skin │ wire contract: wicked-crew-api-types │ API/engine/gates) │
54
- └─────────────────────┘ └──────────────────────┘
63
+
64
+ That's the whole install for most people — no separate studio setup. Prefer a guided setup, or
65
+ want the rest of the wicked family too? Use the installer:
66
+
67
+ ```sh
68
+ npx wicked-installer
55
69
  ```
56
70
 
57
- ## The division of labor
71
+ It installs and wires wicked-crew (which serves this UI) alongside the other wicked-\* tools,
72
+ across whichever coding-agent CLIs you already use.
58
73
 
59
- - **wicked-crew is the control plane** — the daemon, the `/api/v1` REST surface, the `/ws`
60
- event stream, the wicked-core engine underneath, the gates and the evidence. It is fully
61
- functional headless.
62
- - **wicked-studio is the skin** — a client of that control plane, developed, versioned, and
63
- released as its own product. It imports **zero** crew source; the only thing the two share is
64
- the published wire contract, [`wicked-crew-api-types`](https://github.com/mikeparcewski/wicked-crew/tree/main/packages/crew-api-types).
65
- - **Crew still ships a default skin.** wicked-crew's release build (`build:with-studio`) copies
66
- this package's built `dist/` into the daemon's serving tree, so `npx wicked-crew serve` keeps
67
- the one-command local UX — UI and API same-origin on one port. The dependency direction is
68
- *control-plane-ships-a-dist-artifact*: crew depends on studio's build output, never on its
69
- source; studio depends on crew's wire contract, never on its internals.
74
+ ## Keeping it up to date
70
75
 
71
- ## Pairing with a daemon
76
+ Studio rides along with crew, so you update it by updating crew:
72
77
 
73
- The connection surface is deliberately small (`src/api/client.ts`):
78
+ ```sh
79
+ npm i -g wicked-crew@latest # or: npx wicked-installer (updates the whole family)
80
+ ```
74
81
 
75
- | Mode | How the SPA finds the daemon |
76
- |---|---|
77
- | **Bundled / same-origin** (production) | `window.location.origin` — whatever origin the daemon serves the SPA from is where the SPA calls back to. `--port` / `CREW_PORT` just work; no host is baked into the bundle. |
78
- | **Split dev or standalone** | `VITE_API_HOST` (host:port, no scheme), baked at build time by Vite. `.env.development` sets `127.0.0.1:7701` — the crew daemon's default — for the `npm run dev` server on :4200. |
82
+ Each wicked-crew release bundles the matching studio build, so a fresh crew is a fresh UI. To see
83
+ what changed, check the [releases](https://github.com/mikeparcewski/wicked-crew/releases).
79
84
 
80
- The daemon's loopback CORS admits any `http://localhost:*` / `http://127.0.0.1:*` origin, so a
81
- standalone studio on its own port can drive a local daemon out of the box.
85
+ ## Requirements
82
86
 
83
- ## Install
87
+ - **Node.js ≥ 22**, npm ≥ 10
88
+ - A running **wicked-crew daemon, v0.7.0+** (bundled and started for you by `npx wicked-crew serve`
89
+ — you only need this floor if you point a standalone studio at your own daemon)
90
+ - A modern browser — Chrome, Edge, or Firefox on macOS, Linux, or Windows (or Safari on macOS)
84
91
 
85
- You rarely install studio directly: **`npx wicked-crew serve` ships this UI bundled**,
86
- same-origin on one port. Or use the family installer — [`npx wicked-installer`](https://www.npmjs.com/package/wicked-installer)
87
- installs/updates the whole wicked-\* family (wicked-crew, which serves this skin, included).
88
- For a studio you build and host yourself, see [Standalone build](#standalone-build).
92
+ ---
89
93
 
90
- ## Develop
94
+ ## For developers
91
95
 
92
- ```sh
93
- # a running control plane (defaults to 127.0.0.1:7701)
94
- npx wicked-crew serve
96
+ Studio is a Vite/React SPA and a *pure HTTP/WS client* of the wicked-crew daemon — it talks only to
97
+ crew's published `/api/v1` REST surface and `/ws` event stream, and imports **zero** crew source.
98
+ The one thing the two share is the wire-contract package
99
+ [`wicked-crew-api-types`](https://github.com/mikeparcewski/wicked-crew/tree/main/packages/crew-api-types).
100
+
101
+ ```
102
+ ┌─────────────────┐ HTTP /api/v1 + WS /ws ┌────────────────────┐
103
+ │ wicked-studio │ ───────────────────────────▶ │ wicked-crew daemon │
104
+ │ (React SPA) │ ◀─────────────────────────── │ API · engine · │
105
+ │ │ contract: wicked-crew-api-types │ gates · evidence │
106
+ └─────────────────┘ └────────────────────┘
107
+ ```
108
+
109
+ ### Develop
95
110
 
96
- # then, in this repo
111
+ ```sh
112
+ npx wicked-crew serve # a control plane on :7701 for the SPA to talk to
97
113
  npm install
98
- npm run dev # vite on http://127.0.0.1:4200, pointed at :7701 via .env.development
114
+ npm run dev # vite on http://127.0.0.1:4200, pointed at :7701
99
115
  ```
100
116
 
101
117
  `npm test` (vitest + testing-library), `npm run typecheck`, `npm run lint`, `npm run build`
102
- (tsc + vite → `dist/`). CI runs all four on every PR.
118
+ (tsc + vite → `dist/`). CI runs all four on ubuntu / macos / windows for every PR.
119
+
120
+ ### Standalone build
103
121
 
104
- ## Standalone build
122
+ You can build studio and host it yourself, pointed at any reachable daemon:
105
123
 
106
124
  ```sh
107
125
  VITE_API_HOST=127.0.0.1:7701 npm run build
108
- # serve dist/ from ANY static server (SPA fallback to index.html), e.g.:
109
- npx serve dist # or python -m http.server -d dist
126
+ npx serve dist # any static server with SPA fallback works
110
127
  ```
111
128
 
112
- `e2e/studio_standalone_test.py` is the scripted proof of this mode: it builds the SPA, serves
113
- `dist/` from a plain static server on its own port, points it at a live daemon, and drives a
114
- real flow (list runs → open a run → approve a human gate → watch CoreEvents over WS) with a
115
- real browser. See the header of that file for prerequisites and knobs.
116
-
117
- ## Releasing / how crew consumes this
118
-
119
- The npm package ships `dist/` only (`files: ["dist"]`). wicked-crew declares `wicked-studio` as
120
- a devDependency and its `build:with-studio` copies `node_modules/wicked-studio/dist` into
121
- `packages/crew/dist/studio`, which the daemon serves same-origin (headless fallback when
122
- absent). Installs from git get a fresh `dist/` via the `prepare` hook
123
- (`scripts/prepare-dist.mjs`); publishers run `npm run build && npm publish` so the tarball is
124
- built from the tagged source.
125
-
126
- ### The data-testid contract (`testid-inventory.json`)
127
-
128
- `testid-inventory.json` (repo root, committed; emitted into `dist/testid-inventory.json` by the
129
- build) is the machine-readable inventory of every `data-testid` the UI declares — the selector
130
- contract that test generators and the model-free campaign runner build against, versioned with
131
- this package. `tests/testidInventory.test.ts` re-scans `src/` and fails CI on any drift, so a
132
- testid change (or a `package.json` version bump — the artifact carries `studioVersion`) ships
133
- only together with a reviewed `npm run manifest:testids` regeneration. The drift-handling
134
- doctrine downstream is embedded in the file's `$doc` header: a selector miss fails the
135
- deterministic run; the authoring agent re-authors against the live DOM; the runner re-records;
136
- the substitution lands in the spec diff. No agentic fallback inside the runner.
137
-
138
- ## Provenance
139
-
140
- Extracted from the wicked-crew monorepo (`packages/studio`) as its own product — the carve kept
141
- the code as-is and preserved the package's full in-monorepo history via `git subtree split`
142
- (92 commits). An earlier, pre-consolidation incarnation of this product is archived read-only at
143
- [wicked-studio-archived](https://github.com/mikeparcewski/wicked-studio-archived).
129
+ The SPA finds its daemon two ways: **bundled/same-origin** (production) calls back to
130
+ `window.location.origin`, so `--port` / `CREW_PORT` just work with no host baked in; **standalone**
131
+ uses `VITE_API_HOST` (host:port, no scheme) fixed at build time. The daemon's loopback CORS admits
132
+ any `localhost` / `127.0.0.1` origin, so a standalone studio drives a local daemon out of the box.
133
+ `e2e/studio_standalone_test.py` is the scripted proof of this mode.
144
134
 
145
- ## Requirements
135
+ ### How crew ships this UI
136
+
137
+ The npm package publishes `dist/` only. wicked-crew declares `wicked-studio` as a devDependency and
138
+ its `build:with-studio` step copies `node_modules/wicked-studio/dist` into the daemon's serving
139
+ tree, so `npx wicked-crew serve` is same-origin UI + API on one port (with a headless fallback when
140
+ the dist is absent). A studio release therefore also bumps crew's devDep pin.
146
141
 
147
- - Node.js ≥ 22.0.0
148
- - npm ≥ 10 (for workspaces and `prepare` hooks)
149
- - A running [wicked-crew](https://github.com/mikeparcewski/wicked-crew) daemon (**v0.7.0+**) for
150
- the SPA to connect to. The floor is real, not ceremonial: the UI calls routes that first
151
- shipped in crew 0.7.0 — `PUT /runs/:id/guidance` (the durable pre-gate note) exists only
152
- there, and the projects surface, `/audit`, and run archiving need ≥ 0.6.0 — so an older
153
- daemon 404s on surfaces the skin treats as present.
154
- - A modern browser (Chrome, Edge, Firefox, Safari)
155
- - macOS, Linux, or Windows
142
+ The repo also carries a `data-testid` selector contract (`testid-inventory.json`, regenerated with
143
+ `npm run manifest:testids` and drift-checked in CI) that the test generators build against — see
144
+ [`CLAUDE.md`](./CLAUDE.md) for the full contributor doctrine.
156
145
 
157
- ## Contributing
146
+ ### Contributing
158
147
 
159
- 1. Fork the repo and create a feature branch.
148
+ 1. Fork and branch.
160
149
  2. `npm install && npm run dev` — SPA on `:4200`, daemon on `:7701`.
161
150
  3. `npm test && npm run typecheck && npm run lint` before committing.
162
151
  4. Open a PR; CI runs all four gates on ubuntu / macos / windows.
163
152
 
164
- The only external coupling is the wire contract (`wicked-crew-api-types`). Studio imports **zero** crew source — all crew interaction goes through `/api/v1` and `/ws`. Keep it that way.
153
+ Keep the wire-contract boundary intact: all crew interaction goes through `/api/v1` and `/ws`, never
154
+ a crew-source import — if a type is missing, it lands in `wicked-crew-api-types` first.
155
+
156
+ ### Provenance
157
+
158
+ Studio was extracted from the wicked-crew monorepo (`packages/studio`) as its own product,
159
+ preserving the full in-monorepo history via `git subtree split`. An earlier, pre-consolidation
160
+ incarnation is archived read-only at
161
+ [wicked-studio-archived](https://github.com/mikeparcewski/wicked-studio-archived).
165
162
 
166
163
  ## License
167
164