noslopui 0.1.0 → 0.3.0

package/README.md

@@ -6,7 +6,7 @@ Connect your coding agent to [noslopUI](https://noslopui.com) — hand-crafted U
 npx noslopui@latest init
 ```
 
-That one command finds your agent, signs you in through the browser, adds the MCP server to your agent's **user-level** config, and installs the workflow skill. Restart your agent and ask it to build something.
+That one command finds the agents on your machine, signs you in once through the browser, adds the MCP server to each agent's **user-level** config, and installs the workflow skill. Restart your agents and ask one to build something.
 
 ## Why
 
@@ -14,46 +14,86 @@ Ask any agent for a landing page and you get the same page: gradient headline, p
 
 The MCP server is what your agent calls. The skill is what makes it think to call it at all when you say "build me a website" — so `init` installs both, and you can skip the skill with `--no-skill`.
 
+## Supported agents
+
+| Agent | `--agent` | Config it writes | Skill it installs |
+|---|---|---|---|
+| Claude Code | `claude-code` | `~/.claude.json` | `~/.claude/skills/noslopui/` |
+| Codex | `codex` | `~/.codex/config.toml` | `~/.agents/skills/noslopui/` |
+| Cursor | `cursor` | `~/.cursor/mcp.json` | `~/.agents/skills/noslopui/` |
+| VS Code (Copilot) | `vscode` | your user `mcp.json` ¹ | `~/.agents/skills/noslopui/` |
+| Devin Desktop | `devin` | `~/.config/devin/mcp_config.json` ² | `~/.codeium/windsurf/skills/noslopui/` |
+| Windsurf (Cascade) | `windsurf` | `~/.codeium/windsurf/mcp_config.json` | `~/.codeium/windsurf/skills/noslopui/` |
+| OpenCode | `opencode` | `~/.config/opencode/opencode.json` | `~/.agents/skills/noslopui/` |
+| Antigravity | `antigravity` | `~/.gemini/config/mcp_config.json` | `~/.gemini/config/skills/noslopui/` |
+
+¹ `%APPDATA%\Code\User\mcp.json` on Windows, `~/Library/Application Support/Code/User/mcp.json` on macOS, `~/.config/Code/User/mcp.json` on Linux.
+² `%APPDATA%\devin\mcp_config.json` on Windows. Windsurf became Devin Desktop in June 2026: its default agent (Devin Local) reads this file, the older Cascade agent reads the Windsurf one, so they're set up separately.
+
+Every path and field comes from that agent's own documentation. Several agents read the same skills folder, so one copy there serves all of them.
+
+Anything else that speaks MCP over HTTP can be connected by hand — add `https://noslopui.com/api/mcp` and sign in when it asks. Steps for each client: [noslopui.com/mcp](https://noslopui.com/mcp).
+
 ## Commands
 
+**Set up**
+
 | | |
 |---|---|
-| `npx noslopui init` | Set up an agent: sign in, add the server, install the skill |
+| `npx noslopui init` | Set up your agents: one sign-in, then the server and the skill for each |
 | `npx noslopui doctor` | Check what's set up, and say what to do about anything that isn't |
-| `npx noslopui login` | Get a fresh key for an agent that's already set up |
 | `npx noslopui update` | Re-download the skill |
+| `npx noslopui skill` | Install only the skill, for an agent you connected by hand (`--agent <id>`) |
 | `npx noslopui remove` | Take the noslopUI server back out |
 
-Options: `--agent <id>`, `--no-skill`, `--no-browser`, `--key <key>`, `-y/--yes`.
+**Account**
 
-## Supported agents
+| | |
+|---|---|
+| `npx noslopui login` | Sign this CLI in, for the catalog commands below |
+| `npx noslopui login --agent <id>` | A fresh key for an agent that's already set up |
+| `npx noslopui whoami` | The account and plan this CLI is signed in to |
+| `npx noslopui logout` | Forget this CLI's sign-in |
+
+**Catalog**
+
+| | |
+|---|---|
+| `npx noslopui search <query>` | Search UI blocks and Motion Lab effects (`--section ui-blocks\|motion-lab`, `--tag style:editorial`, `--limit`) |
+| `npx noslopui get <id>` | Print a component's code, or `--write src/Hero.tsx` (`--format tsx\|html\|vue`) |
+| `npx noslopui prompt <id>` | Print a component's AI-prompt version |
+| `npx noslopui design-systems [query]` | Search design systems (`--tag theme:dark`) |
+| `npx noslopui design-system <id>` | Print a DESIGN.md, or `--write DESIGN.md` |
+| `npx noslopui collections` | Your saved collections |
+| `npx noslopui collection <name>` | What's in one |
 
-**Claude Code.** That's the list.
+The catalog commands call the same MCP tools your agent does, with the same access: search and collections are free on every account; code, prompts and DESIGN.md files need a paid plan or the account's free trial. Output is only the thing you asked for, so `get <id> > Hero.tsx` works; `--json` gives the raw result.
 
-Other agents are added one at a time, and only after a real install has been done on a real machine, end to end — an agent named here is one we're claiming works. The server enforces the same list: asking for a key for an agent that hasn't passed gets refused, so an out-of-date copy of this CLI can't get one either.
+Options: `--agent <id>` (repeatable), `--no-skill`, `--no-browser`, `--key <key>`, `--json`, `--force`, `-y/--yes`.
 
 ## What it does to your machine
 
-It edits your agent's user-level config, and nothing else. Concretely, for Claude Code:
+It edits your agents' user-level config, and nothing else:
 
-- Adds one entry, `noslopui`, under `mcpServers` in `~/.claude.json`.
-- **Copies the file first.** The backup is written next to the original as `.claude.json.noslopui-backup-<timestamp>`, and its path is printed.
-- **Never touches another server's entry**, or any of the other state Claude Code keeps in that file.
+- Adds one entry, `noslopui`, to each agent you choose, in the file listed above.
+- **Copies the file first.** The backup sits next to the original as `<file>.noslopui-backup-<timestamp>`, and its path is printed.
+- **Never touches another server's entry**, or anything else in the file. Codex's `config.toml` is edited table by table: every line outside `[mcp_servers.noslopui]` is left byte for byte as it was.
 - **Never writes to a project config.** A key in a project file is a key that gets committed.
-- **Stops if the config doesn't parse.** It will not overwrite a file it couldn't read — that file is the only copy of your setup, and guessing at its contents would be worse than doing nothing.
-- Writes the skill to `~/.claude/skills/noslopui/SKILL.md`.
+- **Stops if the config doesn't parse**, or if the `noslopui` entry is written in a form it doesn't recognise. It will not overwrite a file it couldn't read — that file is the only copy of your setup.
+- Writes the skill to the folders listed above.
+- Saves the CLI's own sign-in in `~/.config/noslopui/credentials.json` (`%APPDATA%\noslopui\` on Windows), readable only by you.
 
-`remove` takes the entry back out and leaves everything else, including the skill unless you pass `--skill`. It does **not** revoke your key: the key belongs to your account, not to this machine. Revoke it at [noslopui.com/account](https://noslopui.com/account?tab=mcp).
+`remove` takes the entry back out and leaves everything else, including the skill unless you pass `--skill` — and even then it keeps a skill folder another configured agent still reads. It does **not** revoke your key: the key belongs to your account, not to this machine. Revoke it at [noslopui.com/account](https://noslopui.com/account?tab=mcp).
 
 ### If Claude Code is running
 
 `~/.claude.json` is also Claude Code's own state file, and a running Claude Code rewrites it from memory. Quit it before running `init`, or the entry can be overwritten seconds later. `doctor` re-reads the file rather than trusting the write, so it will tell you if that happened.
 
-## Your key
+## Your keys
 
-`init` issues one key per agent, named after the agent and this machine, so you can tell them apart and revoke one without breaking the others. The key is written to your agent's config and nowhere else — this tool never prints it in full, and never sends it anywhere except noslopui.com.
+`init` issues one key per agent, named after the agent and this machine, so you can tell them apart on the account page and revoke one without breaking the others — plus one for the CLI itself if it isn't signed in yet. Keys are written to each agent's config and nowhere else; this tool never prints one in full, and never sends it anywhere except noslopui.com.
 
-`--key <key>` skips the browser and uses a key you already made on the account page, for CI or a machine with no browser.
+`--key <key>` skips the browser and uses a key you already made on the account page, for CI or a machine with no browser. `NOSLOPUI_API_KEY` does the same for the catalog commands.
 
 ## The skill
 
@@ -72,7 +112,7 @@ npm run typecheck
 
 `NOSLOPUI_ORIGIN` points the CLI at a different server, which is how the flow is exercised against a local one.
 
-Adding an agent is one module implementing `Adapter` (`src/adapters/types.ts`), one line in the registry, and a real install before it goes in the list.
+Adding an agent is its facts in `src/adapters/json-agents.ts` (or its own module, if its config isn't JSON), one line in the registry, the same id in the server's `CLI_AGENTS`, and a row in `test/agents.test.ts`.
 
 ## Licence
 

package/SKILL.md

@@ -11,34 +11,39 @@ AI-generated) UI components, full page examples, and portable Design Systems.
 ## The rules
 
 1. **Choose one design system before fetching any component, then restyle every component to it** — colours, type scale, spacing, radius, motion. One system applied everywhere is what stops a multi-page build reading as a collage.
-2. **Search the whole catalog on fit.** A design system is a set of rules, not an inventory of parts: any component can be built in any system, so nothing is off-limits once one is chosen.
+2. **Search the catalog before hand-building a section, not instead of hand-building it.** Check `search_components` for every required section first — having the design system's tokens and prose isn't a reason to skip that, and any component can be built in any system, so nothing is off-limits once one is chosen. Only build a section yourself if nothing in the catalog fits it, and tell the user that's what happened.
 3. **Never substitute a catalog component for one the user explicitly saved** in a collection. Their pick was a decision, not an oversight.
 4. **Ask about their brand before building** — logo, brand colours, typeface, real photography. Put their values into the system's tokens (their colour replaces `accent`) and keep the system's rules.
-5. **Check for a collection first:** call `list_collections`. If one fits the request, build from it. If none fits, or no key is configured, don't guess a collection — shortlist two or three design systems with `search_design_systems` and let the user pick.
+5. **A collection existing is not the same as the user asking for it.** `list_collections` is free to call, but only build from what it returns when the user asked for their saved items by name or in substance, or confirmed it when you asked. The default "Favorites" list is just where the save button drops a single item with zero setup — a lone design system sitting in it is not a decision to build the whole thing around. One collection with content and no explicit ask → surface it as a question, don't assume either answer. Nothing confirmed → shortlist two or three design systems with `search_design_systems` and let the user pick.
 6. **If a gated tool says the trial has ended or the fair-use limit is reached, tell the user and stop** — don't retry, and don't swap in something generated from scratch.
+7. **A Motion Lab effect is a signature moment, not a section.** Reach for one (`search_components` with `section: "motion_lab"`) when the user asks for an effect, motion, 3D or a showpiece, or the brief clearly calls for one — then use one per page unless they ask for more. Recolour it through its `colorVars` to the design system's tokens, follow its `usage`, and keep its reduced-motion fallback.
 
-Setup, if a tool says no key is configured: the user creates an API key at
-`noslopui.com/account` (MCP tab) and adds it to this MCP server's config as an
-`Authorization: Bearer <key>` header. Search, metadata and design-system token
-tools work without one. Code, prompts and DESIGN.md files need a key on a paid
-plan or inside the account's free 3-day trial, which the first such call
-starts.
+Setup, if the noslopUI tools aren't available: the user runs
+`npx noslopui@latest init`, or adds `https://noslopui.com/api/mcp` in their
+agent and signs in when it asks (steps for each agent: `noslopui.com/mcp`).
+Every call runs as the user's account. Search, metadata and collections are
+free on every account. Code, prompts and DESIGN.md files need a paid plan or
+the account's free 3-day trial, which the first such call starts.
 
 ---
 
 ## Step 0 — Which path?
 
-**Call `list_collections` first.** It's free on every account.
-
-- A relevant collection exists → **Path A**. The user already did the choosing.
-- No collection, or nothing relevant → **Path B**.
-- It says no key is configured → **Path B**, without calling `get_collection`
-  (it needs the same key, and a guessed collection name finds nothing). Tell the
-  user once that code and DESIGN.md files will need a key — see Setup above —
-  and carry on with everything that works without one.
-
-Several collections and no obvious match → ask. Don't guess between two curated
-sets.
+**Call `list_collections` first.** It's free on every account. But a
+collection existing is not the same as the user asking you to build from it —
+the default "Favorites" list is just where the save button puts a single item
+with zero setup, so a design system sitting there alone is very often a saved
+reference, not a decision. Don't let its mere presence override what the user
+actually asked for.
+
+- The user already said to use their saved items ("build from my collection",
+  "use what I've saved", names a list by name) → **Path A**, no need to ask.
+- Nothing was said either way, but exactly one collection has content that
+  looks relevant → **ask**: name what's in it and let them choose Path A or
+  Path B. Don't assume silently in either direction.
+- No collection, or nothing in any of them fits → **Path B**.
+- Several collections and no obvious match → ask which one. Don't guess
+  between two curated sets.
 
 ---
 
@@ -68,6 +73,17 @@ Do this on both paths, before choosing a system. Two groups of things.
 No brand at all → say so plainly and use the design system's own palette. Don't
 invent a logo.
 
+No real photography → don't ship a grey box. Use a seeded placeholder from
+[Picsum](https://picsum.photos) — `https://picsum.photos/seed/<brand-slug>-<slot-name>/<w>/<h>`
+— so the same build gets the same photo on every regenerate instead of a new
+random one. Mark every one with `<!-- TODO: Replace with real photo, target
+size <w>x<h> -->` immediately above it, and write alt text for the *intended*
+subject ("Hand-poured ceramic mug, studio lighting"), not the placeholder
+("Picsum image"), so it's already correct once they swap it in. Skip
+photography altogether where the chosen design system's own register is
+photo-free (type-led, editorial, most SaaS) rather than forcing a stock photo
+in where the system doesn't call for one.
+
 If the user already stated all this, don't re-ask — restate it in one line and
 move on.
 
@@ -76,8 +92,9 @@ move on.
 ## Path A — the user curated a collection
 
 `get_collection({ listId })` (or `name`). Every item carries a `kind` —
-`design_systems` or `ui_blocks` — plus a top-level `designSystems` array and a
-`guidance` line.
+`design_systems`, `ui_blocks` or `motion_lab` (an effect) — plus a top-level
+`designSystems` array and a `guidance` line. A saved effect is a pick like any
+other: use it where it fits, restyled as in Step 3.
 
 1. **The collection's design system wins.** One in it → that is the system, no
    searching; `get_design_system_file` for its DESIGN.md. More than one → ask
@@ -87,8 +104,10 @@ move on.
    something that covers a section, use it. Always. **Never substitute a
    catalog component for one they explicitly saved**, even if you found
    something you think is better — that was their call, not an oversight.
-3. **Fill the gaps with `search_components`**, searching the whole catalog on
-   fit, and restyle what you find to the collection's design system.
+3. **Fill the gaps with `search_components`, checked before you hand-build
+   anything.** Search the whole catalog on fit, and restyle what you find to
+   the collection's design system. Only build a gap section yourself if
+   nothing in the catalog fits it, and say so in step 4's report.
 4. **Report what you filled in.** "Hero, pricing and footer from your
    collection; you had no testimonial section saved, so I pulled one from the
    catalog and restyled it." They should never have to diff the result to find
@@ -111,12 +130,27 @@ Then filter with `tags` (ANDed) and/or a free-text `query` built from the tone
 words plus purpose:
 
 ```
-search_design_systems({ tags: ["theme:light", "industry:local-business"] })
-search_design_systems({ query: "calm minimal saas", tags: ["theme:light"] })
+search_design_systems({ tags: ["industry:hair-beauty"] })
+search_design_systems({ tags: ["industry:dentist", "theme:light"] })
+search_design_systems({ query: "calm minimal", tags: ["industry:saas"] })
 ```
 
-A system can carry several `industry:` tags — a developer-tools system is
-often a SaaS system too — so don't treat one tag as excluding the others.
+`industry:` is a two-level tree, shaped like a template marketplace's: a
+**field** (`food-drink`, `medical`, `home-services`, `technology`…) and, under
+it, **niches** (`restaurant`, `dentist`, `roofing`, `saas`…). Every system
+tagged with a niche is also tagged with its field, so start with the niche if
+the brief names one and widen to the field when that returns fewer than three.
+
+**"Local business" is not an industry — name the trade.** A plumber is
+`home-services`, a barber `hair-beauty`, a café `food-drink`, a physio
+`medical`, a yoga studio `wellness`, an accountant `professional-services`.
+Each of those looks and reads differently, and filtering on the specific field
+is what keeps two local businesses from getting the same site.
+
+A system can carry several fields — a warm serif system serves a restaurant, a
+wedding planner and a spa alike — so don't treat one tag as excluding the
+others, and don't pick the same system for every brief in a field: read the
+descriptions and match the tone the user described.
 
 Every result comes back with its tags, its token summary (colours, fonts,
 radius) and a `previewUrl`. **Present the 2-3 best matches to the user with
@@ -139,11 +173,32 @@ work.
 
 ### B2. Find components on fit
 
-For each required section, call `search_components` — `section`, `framework`
-and `tags` filters as needed, with `tags` ANDed the same way
-(`["style:editorial"]`, `["animation:carousel"]`). Pick the best
-**structural** match: the thing that actually does what the section needs.
-Largely ignore how it currently looks; you are restyling it regardless.
+**Never write a section's markup from scratch before checking the catalog.**
+Having the DESIGN.md in hand is not the same as being done searching — for
+*every* required section, call `search_components` first — `section` and
+`tags` filters as needed, with `tags` ANDed the same way (`["style:editorial"]`,
+`["animation:carousel"]`). Pick the best **structural** match: the thing that
+actually does what the section needs. Largely ignore how it currently looks;
+you are restyling it regardless. Only once nothing in the catalog fits a
+section is hand-building it acceptable — and say so, don't pass it off as a
+catalog pick.
+
+Every result is published as React/TSX with Tailwind classes, whatever stack
+the build target is. That's not a limitation — the markup and styling aren't
+React-specific, so converting a result to plain HTML, Vue, or anything else is
+a mechanical step (`className` to `class`, drop event-handler props, etc.),
+not a rebuild. Never skip a structurally-right component, or conclude the
+catalog has nothing for a non-React project, over its source format.
+
+**Effects are a separate kind.** `section: "motion_lab"` searches Motion Lab:
+shader backgrounds, 3D, liquid glass, text, cursor and scroll effects. An
+effect isn't a section of the page — it's the one moment people remember the
+page for. Use one where the brief asks for it (an effect, motion, 3D, "make it
+pop") or clearly calls for a showpiece, and one per page unless the user asks
+for more. `get_component` tells you how: `usage` says where it earns its
+place, `props` are its knobs, `colorVars` are the CSS custom properties its
+colours come from, and `libraries` are the exact npm packages and versions to
+install.
 
 Then `get_component_code` for the ones you'll use.
 
@@ -168,6 +223,13 @@ result *theirs* rather than a nice demo:
   Body text stays the system's text face unless they insist.
 - Their photography replaces placeholder imagery at the same crops and ratios.
 
+**C. Effects take the system's colours through their variables.** A Motion
+Lab effect exposes each colour as a CSS custom property (`colorVars`, e.g.
+`--ml-accent`) and as a prop. Set those from the system's tokens — the brand
+accent, the darkest surface — and tune its `props` toward the system's motion
+rules (slower if the system is calm). Never recolour inside a shader or
+script, and never remove its reduced-motion fallback.
+
 **Substitute values, keep the rules.** The system's spacing scale, radius
 discipline, contrast requirements and "one accent moment per screen" all still
 apply after the swap — that is the point of a system: it survives a brand
@@ -200,7 +262,9 @@ exists to avoid — catch them here rather than shipping them:
 - **Spacing** — compose from the DESIGN.md's spacing scale; don't invent
   in-between values. Prefer more whitespace over a denser grid.
 - **Motion** — only where it communicates a real state change; the DESIGN.md's
-  durations and easing, never a default bounce or spring.
+  durations and easing, never a default bounce or spring. The one exception is
+  a Motion Lab effect placed where its `usage` says it earns its place — one
+  per page, recoloured to the system.
 - **Named slop-tells to actively reject**: gradient text, purple-on-purple
   palettes, bounce/spring easing on everything, every layout centered with no
   asymmetry, decorative-only animation.
@@ -208,8 +272,8 @@ exists to avoid — catch them here rather than shipping them:
 ## Step 5 — Point back to the catalog for variations
 
 If the result doesn't land, don't re-prompt the same component blind. Point the
-user at `noslopui.com/explore` (cross-catalog search across UI Blocks and
-Design Systems in one grid) to browse real alternatives, and at the
+user at `noslopui.com/explore` (every UI block in one grid, with Motion Lab and
+design-system shelves) to browse real alternatives, and at the
 Collections tab on `noslopui.com/account` to save the ones they like — which
 turns the next build into Path A. Then repeat from Step 3 with whatever they
 pick.
@@ -222,18 +286,19 @@ pick.
 list_collections({})                                           -> { collections: [{ id, name, itemCount }] }
 get_collection({ listId?, name? })                             -> { collection, designSystems: [{id,name}], items: [{ id, name, kind, ... }], guidance }
 
-search_design_systems({ query?, tags?, tag?, limit? })          -> { results: [{ id, name, description, tags, tokens, previewUrl, url }], availableTags }
+search_design_systems({ query?, tags?, tag?, limit? })          -> { results: [{ id, name, description, tags, tokens, previewUrl, url }], availableTags, industryTree }
 get_design_system({ id })                                       -> { id, name, tokens, previewUrl, detailUrl }
 get_design_system_file({ id })                                  -> { id, name, designMd }       [gated: paid or trial]
 
-search_components({ query?, section?, framework?, tags?, tag?, limit? }) -> { results: [{ id, name, kind, tags, url }] }
+search_components({ query?, section?, tags?, tag?, limit? })            -> { results: [{ id, name, kind, tags, url }] }
 get_component({ id })                                             -> { id, name, dependencies, builtWithDesignSystem, previewUrl, detailUrl }
+                                                                     motion_lab items add { usage, props, colorVars, libraries }
 get_component_code({ id })                                         -> { id, name, snippets: [{ language, code }] } [gated: paid or trial]
 get_component_prompt({ id })                                        -> { id, name, promptText }   [gated: paid or trial]
 ```
 
-The key rides on the connection (the `Authorization` header), so no tool needs
-an `apiKey` argument. Every search, metadata and collection tool is free on
+The account rides on the connection (a key or a sign-in, sent as the
+`Authorization` header), so no tool takes a credential argument. Every search, metadata and collection tool is free on
 every account; `get_design_system_file`, `get_component_code` and
 `get_component_prompt` need the account on a paid plan or inside its free
 3-day trial.

package/dist/adapters/claude-code.js

@@ -17,130 +17,30 @@
 // is open while this runs, it can overwrite our entry when it next saves.
 // That's why install tells the user to quit Claude Code first, and why
 // `doctor` re-checks rather than trusting that the write stuck.
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { delimiter, dirname, join } from 'node:path';
-import { backupFile, detectIndent, readJsonFile, writeJsonFile } from '../lib/json-file.js';
-/** The name the server appears under. Also what the user types: `/mcp__noslopui__build_ui`. */
-export const SERVER_NAME = 'noslopui';
-const SKILL_DIR_NAME = 'noslopui';
-function onPath(binary) {
-    const paths = (process.env.PATH ?? '').split(delimiter).filter(Boolean);
-    const suffixes = process.platform === 'win32' ? (process.env.PATHEXT ?? '.EXE;.CMD;.BAT').split(';') : [''];
-    for (const dir of paths) {
-        for (const suffix of suffixes) {
-            try {
-                if (existsSync(join(dir, binary + suffix)))
-                    return true;
-            }
-            catch {
-                // An unreadable PATH entry is not our problem; keep looking.
-            }
-        }
-    }
-    return false;
-}
-export class ClaudeCodeAdapter {
-    id = 'claude-code';
-    label = 'Claude Code';
-    configPath() {
-        return join(homedir(), '.claude.json');
+import { join } from 'node:path';
+import { JsonConfigAdapter, SERVER_NAME } from './json-adapter.js';
+import { home } from '../lib/paths.js';
+import { installSkillAt } from '../lib/skill-file.js';
+export { SERVER_NAME };
+export class ClaudeCodeAdapter extends JsonConfigAdapter {
+    constructor() {
+        super({
+            id: 'claude-code',
+            label: 'Claude Code',
+            configPath: () => join(home(), '.claude.json'),
+            container: 'mcpServers',
+            urlField: 'url',
+            fixed: { type: 'http' },
+            detectPaths: () => [join(home(), '.claude.json'), join(home(), '.claude')],
+            detectBinaries: ['claude'],
+            skillPath: () => join(home(), '.claude', 'skills', 'noslopui', 'SKILL.md'),
+            readBackHint: 'If Claude Code is running, quit it and run this again.',
+        });
     }
     skillPath() {
-        return join(homedir(), '.claude', 'skills', SKILL_DIR_NAME, 'SKILL.md');
-    }
-    async detect() {
-        try {
-            return onPath('claude') || existsSync(this.configPath()) || existsSync(join(homedir(), '.claude'));
-        }
-        catch {
-            return false;
-        }
-    }
-    async install(entry) {
-        const path = this.configPath();
-        const config = readJsonFile(path) ?? {};
-        const backupPath = backupFile(path);
-        const servers = (typeof config.mcpServers === 'object' && config.mcpServers !== null && !Array.isArray(config.mcpServers)
-            ? config.mcpServers
-            : {});
-        const replacedExisting = SERVER_NAME in servers;
-        // Spread the existing entry so anything Claude Code (or the user) added to
-        // it that we don't know about survives the update.
-        const existing = (typeof servers[SERVER_NAME] === 'object' && servers[SERVER_NAME] !== null ? servers[SERVER_NAME] : {});
-        const existingHeaders = (typeof existing.headers === 'object' && existing.headers !== null ? existing.headers : {});
-        servers[SERVER_NAME] = {
-            ...existing,
-            type: 'http',
-            url: entry.url,
-            headers: { ...existingHeaders, Authorization: `Bearer ${entry.key}` },
-        };
-        config.mcpServers = servers;
-        writeJsonFile(path, config, { indent: existsSync(path) ? detectIndent(path) : 2 });
-        // Read back: this file has another writer, so a successful write is not
-        // the same as a config that says what we think it says.
-        const after = await this.status();
-        if (!after.installed || after.url !== entry.url || !after.hasKey) {
-            throw new Error(`The entry was written to ${path} but reading it back didn't show it. If Claude Code is running, quit it and run this again.`);
-        }
-        return { configPath: path, backupPath, method: 'config-file', replacedExisting };
-    }
-    async status() {
-        const path = this.configPath();
-        const config = readJsonFile(path);
-        if (!config)
-            return { installed: false, configPath: path, url: null, hasKey: false };
-        const servers = config.mcpServers;
-        const entry = servers?.[SERVER_NAME];
-        if (!entry)
-            return { installed: false, configPath: path, url: null, hasKey: false };
-        const url = typeof entry.url === 'string' ? entry.url : null;
-        const headers = (entry.headers ?? {});
-        const auth = typeof headers.Authorization === 'string' ? headers.Authorization : '';
-        const hasKey = /^Bearer\s+\S+/i.test(auth);
-        let problem;
-        if (!url)
-            problem = 'The entry has no url.';
-        else if (!hasKey)
-            problem = 'The entry has no Authorization header, so gated tools will be refused.';
-        else if (entry.type !== 'http')
-            problem = `The entry's type is "${String(entry.type)}", expected "http".`;
-        return { installed: true, configPath: path, url, hasKey, ...(problem ? { problem } : {}) };
-    }
-    async uninstall() {
-        const path = this.configPath();
-        const config = readJsonFile(path);
-        if (!config)
-            return false;
-        const servers = config.mcpServers;
-        if (!servers || !(SERVER_NAME in servers))
-            return false;
-        backupFile(path);
-        delete servers[SERVER_NAME];
-        writeJsonFile(path, config, { indent: detectIndent(path) });
-        return true;
+        return join(home(), '.claude', 'skills', 'noslopui', 'SKILL.md');
     }
     async installSkill(markdown) {
-        const path = this.skillPath();
-        if (existsSync(path)) {
-            try {
-                if (readFileSync(path, 'utf8') === markdown)
-                    return { path, changed: false };
-            }
-            catch {
-                // Unreadable but present: fall through and replace it.
-            }
-        }
-        mkdirSync(dirname(path), { recursive: true });
-        writeFileSync(path, markdown, 'utf8');
-        return { path, changed: true };
-    }
-    async removeSkill() {
-        const path = this.skillPath();
-        if (!existsSync(path))
-            return false;
-        // Only our own folder, and only because we created it.
-        rmSync(dirname(path), { recursive: true, force: true });
-        return true;
+        return installSkillAt(this.skillPath(), markdown);
     }
 }