claude-toolkit 0.1.9

package/src/types.ts

@@ -0,0 +1,85 @@
+/** Available stack identifiers */
+export type StackName =
+	| "solidjs"
+	| "vanilla-extract"
+	| "rust-wasm"
+	| "protobuf"
+	| "cloudflare"
+	| "i18n-typesafe"
+	| (string & {});
+
+/** Hook configuration for post-tool-use automation */
+export interface HookConfig {
+	/** Formatter command (e.g., "bun run prettier --write") */
+	formatter?: string;
+	/** Test runner command (e.g., "bun run vitest run") */
+	testRunner?: string;
+	/** Type checker command (e.g., "bun run tsc --noEmit") */
+	typeCheck?: string;
+	/** Additional check commands (e.g., ["cargo check --target wasm32-unknown-unknown"]) */
+	extraChecks?: string[];
+	/** Dependency install command (e.g., "bun install") — inferred from packageManager if omitted */
+	installCommand?: string;
+}
+
+/** Git workflow configuration */
+export interface GitConfig {
+	/** Branch name prefix (e.g., "wq" → "wq/feature-name") */
+	branchPrefix?: string;
+	/** Branches protected from direct edits */
+	protectedBranches?: string[];
+	/** Commit format (default: conventional commits) */
+	commitFormat?: "conventional" | "freeform";
+}
+
+/** Project metadata used in CLAUDE.md generation */
+export interface ProjectInfo {
+	/** Project name */
+	name?: string;
+	/** Short project description */
+	description?: string;
+	/** Key directories and their purpose */
+	directories?: Record<string, string>;
+	/** Common dev commands */
+	commands?: Record<string, string>;
+}
+
+/** Main toolkit configuration */
+export interface ClaudeToolkitConfig {
+	/** Stack packs to activate */
+	stacks: StackName[];
+	/** Package manager to use */
+	packageManager: "bun" | "npm" | "pnpm" | "yarn";
+	/** Hook automation config */
+	hooks?: HookConfig;
+	/** Directory → skill mappings (merged with stack defaults) */
+	directoryMappings?: Record<string, string>;
+	/** Git workflow config */
+	git?: GitConfig;
+	/** Project info for CLAUDE.md generation */
+	project?: ProjectInfo;
+	/** Additional custom skills to include (paths relative to project root) */
+	customSkills?: string[];
+	/** Skills to exclude from core set */
+	excludeSkills?: string[];
+	/** Whether to scaffold base configs (biome.json, tsconfig.json) on init. Default: true */
+	scaffoldConfigs?: boolean;
+}
+
+/** Stack pack metadata (loaded from stack.json) */
+export interface StackPack {
+	name: string;
+	description: string;
+	defaultMappings: Record<string, string>;
+	fileExtensions: string[];
+	hookOverrides?: Partial<HookConfig>;
+}
+
+/** Resolved configuration after merging core + stacks + project config */
+export interface ResolvedConfig {
+	config: ClaudeToolkitConfig;
+	skills: string[];
+	directoryMappings: Record<string, string>;
+	hooks: HookConfig;
+	stacks: StackPack[];
+}

package/src/utils.ts

@@ -0,0 +1,53 @@
+import { existsSync } from "node:fs";
+import {
+	copyFile,
+	mkdir,
+	readdir,
+	readFile,
+	writeFile,
+} from "node:fs/promises";
+import { dirname, join } from "node:path";
+
+/** Recursively copy a directory */
+export async function copyDir(src: string, dest: string): Promise<void> {
+	await mkdir(dest, { recursive: true });
+	const entries = await readdir(src, { withFileTypes: true });
+	for (const entry of entries) {
+		const srcPath = join(src, entry.name);
+		const destPath = join(dest, entry.name);
+		if (entry.isDirectory()) {
+			await copyDir(srcPath, destPath);
+		} else {
+			await mkdir(dirname(destPath), { recursive: true });
+			await copyFile(srcPath, destPath);
+		}
+	}
+}
+
+/** Write a file, creating parent directories as needed */
+export async function writeFileEnsureDir(
+	filePath: string,
+	content: string,
+): Promise<void> {
+	await mkdir(dirname(filePath), { recursive: true });
+	await writeFile(filePath, content, "utf-8");
+}
+
+/** Read JSON file with type */
+export async function readJson<T>(filePath: string): Promise<T> {
+	const content = await readFile(filePath, "utf-8");
+	return JSON.parse(content) as T;
+}
+
+/** Check if a path exists */
+export function exists(filePath: string): boolean {
+	return existsSync(filePath);
+}
+
+/** Simple template replacement: {{key}} → value */
+export function renderTemplate(
+	template: string,
+	vars: Record<string, string>,
+): string {
+	return template.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? "");
+}

package/stacks/cloudflare/skills/cloudflare-d1-kv/SKILL.md

@@ -0,0 +1,84 @@
+---
+name: ct-cloudflare-d1-kv
+description: Cloudflare D1 SQL database and KV cache patterns
+---
+
+# D1 and KV Patterns
+
+## D1 Conventions
+
+Always use prepared statements with `bind()`. Never concatenate SQL.
+
+```rust
+let stmt = db.prepare("SELECT * FROM users WHERE id = ?1").bind(&[id.into()])?;
+let user = stmt.first::<User>(None).await?;
+```
+
+Batch related queries in a single round trip (transactional -- all succeed or all fail):
+
+```rust
+let results = db.batch(vec![
+    db.prepare("INSERT INTO events (id, name) VALUES (?1, ?2)").bind(&[id.into(), name.into()])?,
+    db.prepare("INSERT INTO event_members (event_id, user_id) VALUES (?1, ?2)").bind(&[id.into(), uid.into()])?,
+]).await?;
+```
+
+### Schema Rules
+
+- `TEXT` for IDs (UUIDs/nanoids, not auto-increment).
+- `TEXT` for timestamps in ISO 8601.
+- Always add `created_at` and `updated_at` columns.
+- Always index columns used in WHERE/JOIN.
+- Use `IF NOT EXISTS`/`IF EXISTS` for idempotent migrations.
+
+### Migration Workflow
+
+```bash
+wrangler d1 migrations create DB "add_users_table"
+# Edit migrations/0001_add_users_table.sql, then:
+wrangler d1 migrations apply DB --local   # test locally first
+wrangler d1 migrations apply DB --remote
+```
+
+## KV Conventions
+
+KV is eventually-consistent. Use for read-heavy caching only, not primary data.
+
+### Read-Through Cache
+
+```rust
+async fn get_cached(kv: &KvStore, db: &D1Database, id: &str) -> Result<User> {
+    let key = format!("user:{}", id);
+    if let Some(cached) = kv.get(&key).text().await? {
+        if let Ok(user) = serde_json::from_str::<User>(&cached) { return Ok(user); }
+    }
+    let user = db.prepare("SELECT * FROM users WHERE id = ?1")
+        .bind(&[id.into()])?.first::<User>(None).await?.ok_or(AppError::NotFound)?;
+    kv.put(&key, &serde_json::to_string(&user)?)?.expiration_ttl(3600).execute().await?;
+    Ok(user)
+}
+```
+
+Invalidate on writes: `kv.delete(&format!("user:{}", id)).await?;`
+
+### Key Naming
+
+Colon-separated hierarchical: `user:{id}`, `user:{id}:profile`, `cache:feed:{uid}:page:{n}`
+
+### TTL Guidelines
+
+| Data | TTL | Reason |
+|------|-----|--------|
+| User profile | 1h | Infrequent changes |
+| Session | 24h | Matches session lifetime |
+| Config | 5min | Needs fast propagation |
+| Public listings | 15min | Freshness vs load balance |
+
+## Anti-Patterns
+
+1. **Unbounded queries** -- Always LIMIT. D1 has 5MB response cap.
+2. **Missing indexes** -- D1 is SQLite; no index = full table scan.
+3. **KV as primary store** -- Eventually consistent, no queries. Cache only.
+4. **Skipping batch** -- Each D1 call is a network round trip.
+5. **KV without TTL** -- Stale data persists indefinitely.
+6. **Untested migrations** -- Always `--local` before `--remote`.

package/stacks/cloudflare/stack.json

@@ -0,0 +1,26 @@
+{
+	"name": "ct-cloudflare-d1-kv",
+	"description": "Cloudflare D1 database and KV cache patterns",
+	"defaultMappings": {
+		"src/db": "ct-cloudflare-d1-kv",
+		"migrations": "ct-cloudflare-d1-kv"
+	},
+	"fileExtensions": ["sql"],
+	"skillRules": {
+		"ct-cloudflare-d1-kv": {
+			"description": "Cloudflare D1 SQL and KV cache patterns",
+			"priority": 7,
+			"triggers": {
+				"keywords": ["d1", "kv", "cloudflare", "wrangler", "database", "cache", "sql", "migration"],
+				"keywordPatterns": ["\\bd1\\b", "\\bkv\\b", "\\bwrangler\\b", "\\bmigration\\b"],
+				"pathPatterns": ["**/migrations/**", "**/*.sql", "**/db/**", "**/wrangler.toml"],
+				"intentPatterns": [
+					"(?:create|add|run).*(?:migration|query|table)",
+					"(?:cache|store|fetch).*(?:data|value|key)"
+				],
+				"contentPatterns": ["D1Database", "KVNamespace", "env\\.DB", "env\\.KV", "prepared\\("]
+			},
+			"relatedSkills": ["ct-rust-wasm-patterns"]
+		}
+	}
+}

package/stacks/i18n-typesafe/skills/i18n-typesafe/SKILL.md

@@ -0,0 +1,64 @@
+---
+name: ct-i18n-typesafe
+description: Typesafe-i18n internationalization patterns for SolidJS
+---
+
+# Typesafe-i18n Patterns
+
+Fully type-safe translations. Missing/misspelled keys cause TypeScript errors at compile time.
+
+## Base Locale (Source of Truth)
+
+All types are derived from the base locale. Other locales implement `Translation` (type-checked against base).
+
+```ts
+// src/i18n/en/index.ts
+const en = {
+  common: {
+    welcome: 'Welcome, {name:string}!',
+    itemCount: '{count:number} {{item|items}}',
+    save: 'Save',
+    cancel: 'Cancel',
+  },
+  events: {
+    title: 'Events',
+    create: 'Create event',
+    noEvents: 'No events yet',
+    attendees: '{count:number} {{attendee|attendees}}',
+  },
+} satisfies BaseTranslation;
+```
+
+Other locales mirror this structure with `satisfies Translation`. Missing keys or wrong param types cause compile errors.
+
+## Usage in Components
+
+```tsx
+const { LL } = useI18nContext();
+// Simple: LL().common.save()
+// Params: LL().common.welcome({ name: 'Alice' })
+// Plural: LL().events.attendees({ count: 3 }) -> "3 attendees"
+```
+
+Wrap app in `<I18nProvider locale="en">` after calling `loadLocale('en')`.
+
+## Plural Rules
+
+`{{singular|plural}}` selected by preceding number param. For complex plural languages (e.g. Arabic): `{{one|two|many}}`.
+
+## Parameterized Translations
+
+Types are inferred from base locale: `{name:string}`, `{count:number}`. TypeScript enforces correct params at call sites.
+
+## Organization
+
+Organize by feature (common, auth, events), one level deep. Avoid deep nesting -- it makes keys verbose.
+
+## Anti-Patterns
+
+1. **Hardcoded strings** -- Every user-visible string goes through `LL()`.
+2. **Missing translations** -- Caught at compile time, but only if `tsc --noEmit` runs in CI.
+3. **HTML in translations** -- Use component composition instead.
+4. **Dynamic key access** -- `LL()[dynamicKey]()` bypasses type safety. Use conditional rendering.
+5. **Forgetting loadLocale** -- Must call before rendering or get runtime errors.
+6. **Over-splitting namespaces** -- Group by feature, not by component.

package/stacks/i18n-typesafe/stack.json

@@ -0,0 +1,25 @@
+{
+	"name": "ct-i18n-typesafe",
+	"description": "Typesafe internationalization with typesafe-i18n",
+	"defaultMappings": {
+		"src/locales": "ct-i18n-typesafe",
+		"src/i18n": "ct-i18n-typesafe"
+	},
+	"fileExtensions": [],
+	"skillRules": {
+		"ct-i18n-typesafe": {
+			"description": "Typesafe-i18n internationalization patterns",
+			"priority": 6,
+			"triggers": {
+				"keywords": ["i18n", "translation", "locale", "typesafe-i18n", "localization", "translate"],
+				"keywordPatterns": ["\\bi18n\\b", "\\blocale\\b", "\\btranslat"],
+				"pathPatterns": ["**/locales/**", "**/i18n/**"],
+				"intentPatterns": [
+					"(?:add|create).*(?:translation|text|locale)",
+					"(?:translat).*(?:key|string)"
+				],
+				"contentPatterns": ["useI18nContext", "LL\\.", "baseLocale", "Locales"]
+			}
+		}
+	}
+}

package/stacks/protobuf/skills/protobuf-contracts/SKILL.md

@@ -0,0 +1,78 @@
+---
+name: ct-protobuf-contracts
+description: Protocol Buffer definitions and code generation for frontend/backend contracts
+---
+
+# Protobuf Contracts
+
+Proto3 contracts between frontend (TypeScript via protoc-gen-ts) and backend (Rust via prost).
+
+## Conventions
+
+- PascalCase messages, snake_case fields.
+- Fields 1-15 cost 1 byte -- reserve for frequent fields.
+- Enums always start with `UNSPECIFIED = 0`.
+- Package with versioning: `package myapp.v1;`
+
+## Message Patterns
+
+```protobuf
+message UserProfile {
+  string id = 1;
+  string email = 2;
+  string display_name = 3;
+  optional string avatar_url = 4;
+}
+
+// Request/Response pairs
+message GetUserRequest { string user_id = 1; }
+message GetUserResponse { UserProfile user = 1; }
+
+// Pagination
+message ListEventsRequest { int32 page_size = 1; string page_token = 2; }
+message ListEventsResponse { repeated Event events = 1; string next_page_token = 2; int32 total_count = 3; }
+
+// Reserved fields -- never reuse removed field numbers
+message Event {
+  reserved 3, 8;
+  reserved "old_field";
+  string id = 1;
+  string name = 2;
+}
+```
+
+## Service Definitions
+
+```protobuf
+service UserService {
+  rpc GetUser(GetUserRequest) returns (GetUserResponse);
+  rpc CreateUser(CreateUserRequest) returns (CreateUserResponse);
+  rpc ListUsers(ListUsersRequest) returns (ListUsersResponse);
+}
+```
+
+## Code Generation
+
+Frontend: `buf generate --template buf.gen.ts.yaml`
+Backend (build.rs):
+```rust
+prost_build::Config::new()
+    .type_attribute(".", "#[derive(serde::Serialize, serde::Deserialize)]")
+    .compile_protos(&["proto/user.proto"], &["proto/"])?;
+```
+
+## Versioning Rules
+
+- Never remove/renumber fields -- use `reserved`.
+- Never change field types -- add a new field.
+- Adding fields and enum values is safe.
+- Run `buf breaking --against .git#branch=main` before merging.
+
+## Anti-Patterns
+
+1. **Reusing field numbers** -- Causes data corruption. Always reserve removed numbers.
+2. **Deep nesting** -- Hurts readability and evolution. Flatten where practical.
+3. **Missing UNSPECIFIED** -- Proto3 default is 0; without UNSPECIFIED it maps to a real value.
+4. **Proto2 syntax** -- Always proto3 for new projects.
+5. **Skipping buf lint** -- Inconsistent naming compounds. Lint early.
+6. **Large messages** -- Not for multi-MB payloads. Use streaming/chunking.

package/stacks/protobuf/stack.json

@@ -0,0 +1,25 @@
+{
+	"name": "ct-protobuf-contracts",
+	"description": "Protobuf contracts between frontend and backend",
+	"defaultMappings": {
+		"proto": "ct-protobuf-contracts"
+	},
+	"fileExtensions": ["proto"],
+	"skillRules": {
+		"ct-protobuf-contracts": {
+			"description": "Protocol Buffer definitions and code generation",
+			"priority": 8,
+			"triggers": {
+				"keywords": ["protobuf", "proto", "protocol buffer", "grpc", "prost", "protoc", "buf"],
+				"keywordPatterns": ["\\bproto\\b", "\\bprotobuf\\b", "\\bprost\\b", "\\bbuf\\b"],
+				"pathPatterns": ["**/*.proto", "**/proto/**", "**/*.pb.ts"],
+				"intentPatterns": [
+					"(?:define|create|add).*(?:message|service|rpc|contract)",
+					"(?:proto|protobuf).*(?:schema|type|definition)"
+				],
+				"contentPatterns": ["syntax.*proto3", "message\\s+\\w+", "service\\s+\\w+", "rpc\\s+\\w+"]
+			},
+			"relatedSkills": ["ct-rust-wasm-patterns"]
+		}
+	}
+}

package/stacks/rust-wasm/skills/rust-wasm-patterns/SKILL.md

@@ -0,0 +1,76 @@
+---
+name: ct-rust-wasm-patterns
+description: Rust WASM patterns for Cloudflare Workers with worker-rs
+---
+
+# Rust WASM Patterns (Cloudflare Workers)
+
+Target: `wasm32-unknown-unknown`. Crate type: `cdylib`. Always set `console_error_panic_hook`.
+
+## Routing and Handlers
+
+```rust
+#[event(fetch)]
+async fn fetch(req: Request, env: Env, _ctx: Context) -> Result<Response> {
+    console_error_panic_hook::set_once();
+    Router::new()
+        .get_async("/api/users/:id", get_user)
+        .post_async("/api/users", create_user)
+        .run(req, env).await
+}
+
+async fn get_user(req: Request, ctx: RouteContext<()>) -> Result<Response> {
+    let id = ctx.param("id").ok_or_else(|| Error::RustError("Missing id".into()))?;
+    let db = ctx.env.d1("DB")?;
+    match db.prepare("SELECT * FROM users WHERE id = ?1").bind(&[id.into()])?.first::<User>(None).await? {
+        Some(user) => Response::from_json(&user),
+        None => Response::error("Not found", 404),
+    }
+}
+```
+
+## Error Handling
+
+Define a custom error type converting to `worker::Error`:
+
+```rust
+#[derive(Debug)]
+pub enum AppError { NotFound(String), BadRequest(String), Internal(String), Unauthorized }
+
+impl From<AppError> for worker::Error {
+    fn from(e: AppError) -> Self { worker::Error::RustError(format!("{:?}", e)) }
+}
+```
+
+## Env Bindings
+
+```rust
+let db = env.d1("DB")?;                          // D1
+let kv = env.kv("MY_KV")?;                       // KV
+let bucket = env.bucket("MY_BUCKET")?;            // R2
+let key = env.secret("API_KEY")?.to_string();     // Secrets
+let val = env.var("CONFIG_VAR")?.to_string();     // Vars
+```
+
+## Serde Conventions
+
+```rust
+#[derive(Serialize, Deserialize, Debug)]
+pub struct User {
+    pub id: String,
+    pub email: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub avatar_url: Option<String>,
+}
+```
+
+Parse body: `let body: CreateUserRequest = req.json().await?;`
+
+## Anti-Patterns
+
+1. **Panics in production** -- Always `Result`, never `unwrap()`/`expect()`.
+2. **Blocking ops** -- WASM is single-threaded. All I/O must be `async`.
+3. **Large binaries** -- Minimal deps, use `wasm-opt`, target <1MB compressed.
+4. **Buffering large files** -- 128MB memory limit. Stream, don't buffer.
+5. **Raw SQL concatenation** -- Always `bind()` prepared statements.
+6. **Missing CORS** -- Handle OPTIONS preflight for API workers.

package/stacks/rust-wasm/stack.json

@@ -0,0 +1,26 @@
+{
+	"name": "ct-rust-wasm-patterns",
+	"description": "Rust WASM for Cloudflare Workers with worker-rs",
+	"defaultMappings": {
+		"worker": "ct-rust-wasm-patterns",
+		"worker/src": "ct-rust-wasm-patterns"
+	},
+	"fileExtensions": ["rs", "toml"],
+	"skillRules": {
+		"ct-rust-wasm-patterns": {
+			"description": "Rust WASM patterns for Cloudflare Workers",
+			"priority": 8,
+			"triggers": {
+				"keywords": ["rust", "wasm", "worker", "cargo", "wasm-bindgen", "worker-rs", "wrangler"],
+				"keywordPatterns": ["\\brust\\b", "\\bwasm\\b", "\\bcargo\\b", "\\bworker\\b"],
+				"pathPatterns": ["**/*.rs", "**/Cargo.toml", "**/worker/**"],
+				"intentPatterns": [
+					"(?:create|build|add).*(?:endpoint|route|handler|worker)",
+					"(?:rust|wasm).*(?:function|module|binding)"
+				],
+				"contentPatterns": ["worker::.*", "wasm_bindgen", "pub async fn", "Result<", "#\\[worker::"]
+			},
+			"relatedSkills": ["ct-protobuf-contracts", "ct-cloudflare-d1-kv"]
+		}
+	}
+}

package/stacks/solidjs/skills/solidjs-patterns/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: ct-solidjs-patterns
+description: SolidJS reactivity, signals, effects, and component patterns
+---
+
+# SolidJS Patterns
+
+Components run **once**. Only reactive expressions re-execute. This is not React.
+
+## Primitives
+
+```tsx
+const [count, setCount] = createSignal(0);      // always call: count()
+const doubled = createMemo(() => count() * 2);   // cached derived value
+createEffect(() => console.log(count()));         // side effect on change
+const [data] = createResource(userId, fetchUser); // async: data(), data.loading, data.error
+```
+
+## Control Flow
+
+```tsx
+<Show when={ok()} fallback={<Fallback />}><Content /></Show>
+<For each={items()}>{(item, i) => <div>{item.name} at {i()}</div>}</For>
+<Switch fallback={<Default />}>
+  <Match when={state() === "loading"}><Spinner /></Match>
+  <Match when={state() === "error"}><Error /></Match>
+</Switch>
+```
+
+## Props
+
+**CRITICAL: Never destructure props.** Destructuring breaks reactivity.
+
+```tsx
+// WRONG -- reads once, never updates
+const Comp = ({ name }) => <div>{name}</div>;
+
+// CORRECT
+const Comp = (props) => <div>{props.name}</div>;
+```
+
+`mergeProps` for defaults, `splitProps` to separate groups:
+
+```tsx
+const merged = mergeProps({ color: "blue" }, props);
+const [local, others] = splitProps(props, ["class", "style"]);
+```
+
+## Stores
+
+`createStore` for deep nested state with path-based updates:
+
+```tsx
+const [state, setState] = createStore({ user: { settings: { theme: "dark" } } });
+setState("user", "settings", "theme", "light");
+setState("items", items => [...items, newItem]);
+```
+
+## Anti-Patterns
+
+1. **Destructuring props** -- Breaks reactivity. Always `props.x`.
+2. **createEffect for derived values** -- Use `createMemo` instead.
+3. **Treating it like React** -- No re-render cycle. Only reactive expressions update.
+4. **Manual keys in For** -- `<For>` is keyed by reference automatically.
+5. **Signals outside reactive context** -- `count()` at top level captures once. Wrap in JSX or effects.
+6. **Forgetting to call signals** -- `count` is a getter, `count()` is the value.

package/stacks/solidjs/stack.json

@@ -0,0 +1,52 @@
+{
+	"name": "ct-solidjs-patterns",
+	"description": "SolidJS reactivity, components, and resource patterns",
+	"defaultMappings": {
+		"src/components": "ct-solidjs-patterns",
+		"src/hooks": "ct-solidjs-patterns",
+		"src/pages": "ct-solidjs-patterns"
+	},
+	"fileExtensions": ["tsx", "jsx"],
+	"skillRules": {
+		"ct-solidjs-patterns": {
+			"description": "SolidJS reactivity, signals, effects, and component patterns",
+			"priority": 8,
+			"triggers": {
+				"keywords": [
+					"solid",
+					"solidjs",
+					"signal",
+					"createSignal",
+					"createEffect",
+					"createMemo",
+					"createResource",
+					"Show",
+					"For",
+					"Switch",
+					"Match"
+				],
+				"keywordPatterns": [
+					"\\bcreateSignal\\b",
+					"\\bcreateEffect\\b",
+					"\\bcreateResource\\b",
+					"\\bSolid\\b"
+				],
+				"pathPatterns": ["**/*.tsx", "**/*.jsx", "**/components/**"],
+				"intentPatterns": [
+					"(?:create|build|add).*(?:component|page|view)",
+					"(?:reactive|signal|effect|memo)"
+				],
+				"contentPatterns": [
+					"createSignal",
+					"createEffect",
+					"createMemo",
+					"createResource",
+					"<Show",
+					"<For",
+					"<Switch"
+				]
+			},
+			"relatedSkills": ["ct-vanilla-extract-patterns", "ct-testing-patterns"]
+		}
+	}
+}