@webiny/mcp 6.0.0-rc.7 → 6.1.0-beta.0

package/skills/api/use-case-pattern/SKILL.md

@@ -0,0 +1,102 @@
+---
+name: webiny-use-case-pattern
+context: webiny-api
+description: >
+  Generic UseCase implementation pattern — DI, Result handling, extension registration.
+  Use this skill to understand how to implement, inject, or override any Webiny UseCase.
+---
+
+# UseCase Pattern
+
+## What It Is
+
+A **UseCase** is a named operation that encapsulates business logic (e.g., `CreateTenantUseCase`, `PublishEntryUseCase`). Each UseCase is a DI abstraction with a single `execute` method.
+
+## Interface Shape
+
+Every UseCase follows this pattern:
+
+```ts
+interface SomeUseCase.Interface {
+    execute(input: Input): Promise<Result<ReturnType, ErrorType>>;
+}
+```
+
+- **Input** — a typed object specific to the use case
+- **Result** — always returns `Result<T, E>` from `@webiny/feature/api`
+- **Error** — extends `BaseError` with a unique `code`
+
+## How to Use a UseCase
+
+UseCases are injected as dependencies into EventHandlers or other UseCases via DI.
+
+```ts
+import { SomeUseCase } from "webiny/api/<category>";
+import { SomeEventHandler } from "webiny/api/<category>";
+
+class MyHandler implements SomeEventHandler.Interface {
+    constructor(private someUseCase: SomeUseCase.Interface) {}
+
+    async handle(event: SomeEventHandler.Event) {
+        const result = await this.someUseCase.execute({ /* input */ });
+
+        if (result.isFail()) {
+            console.error(result.error.message);
+            return;
+        }
+
+        const value = result.value;
+        // ... use value
+    }
+}
+
+export default SomeEventHandler.createImplementation({
+    implementation: MyHandler,
+    dependencies: [SomeUseCase]
+});
+```
+
+## How to Override a UseCase
+
+To replace the default implementation, register your own:
+
+```ts
+import { SomeUseCase } from "webiny/api/<category>";
+
+class CustomImplementation implements SomeUseCase.Interface {
+    async execute(input) {
+        // Custom logic
+        return Result.ok(/* ... */);
+    }
+}
+
+export default SomeUseCase.createImplementation({
+    implementation: CustomImplementation,
+    dependencies: []
+});
+```
+
+## Registration
+
+```tsx
+// In your app's configuration
+<Api.Extension src={"@/extensions/my-extension.ts"} />
+```
+
+Deploy with: `yarn webiny deploy api --env=dev`
+
+## Resolving Types (MANDATORY)
+
+**Before writing any code that calls a UseCase or accesses its return types, you MUST read the source file listed in the catalog's `Source` field to verify the exact method signatures, input parameters, return types, and error types. Do not assume or guess property names from memory.**
+
+To see the exact types for a specific UseCase:
+
+1. Read the `abstractions.ts` file from the catalog `Source` path — it contains the `Interface` with the full method signature, input types, and error union.
+2. If the interface references domain types (e.g., `CmsEntry`, `CmsModel`), follow the import and read that type declaration too.
+3. Only use properties and method signatures that are confirmed to exist in the source type declarations.
+
+## Key Rules
+
+- Always check `result.isOk()` or `result.isFail()` before accessing `.value` or `.error`
+- DI constructor parameter order must match the `dependencies` array order exactly
+- Use `.js` extensions in import paths (ES modules)

package/skills/cli-extensions/SKILL.md

@@ -23,39 +23,36 @@ import { Ui } from "webiny/cli";
 import { CliCommandFactory } from "webiny/cli/command";
 
 export interface IMyCustomCommandParams {
-    name: string;
+  name: string;
 }
 
 class MyCustomCommandImpl implements CliCommandFactory.Interface<IMyCustomCommandParams> {
-    constructor(private ui: Ui.Interface) {}
-
-    execute(): CliCommandFactory.CommandDefinition<IMyCustomCommandParams> {
-        return {
-            name: "my-custom-command",
-            description: "This is my custom command",
-            examples: [
-                "$0 my-custom-command test1",
-                "$0 my-custom-command test2"
-            ],
-            params: [
-                {
-                    name: "name",
-                    description: "Your name",
-                    type: "string"
-                }
-            ],
-            handler: async params => {
-                this.ui.info("Starting my custom command...");
-                this.ui.emptyLine();
-                this.ui.success(`Hello, ${params.name}! This is my custom command.`);
-            }
-        };
-    }
+  constructor(private ui: Ui.Interface) {}
+
+  execute(): CliCommandFactory.CommandDefinition<IMyCustomCommandParams> {
+    return {
+      name: "my-custom-command",
+      description: "This is my custom command",
+      examples: ["$0 my-custom-command test1", "$0 my-custom-command test2"],
+      params: [
+        {
+          name: "name",
+          description: "Your name",
+          type: "string"
+        }
+      ],
+      handler: async params => {
+        this.ui.info("Starting my custom command...");
+        this.ui.emptyLine();
+        this.ui.success(`Hello, ${params.name}! This is my custom command.`);
+      }
+    };
+  }
 }
 
 export default CliCommandFactory.createImplementation({
-    implementation: MyCustomCommandImpl,
-    dependencies: [Ui]
+  implementation: MyCustomCommandImpl,
+  dependencies: [Ui]
 });
 ```
 
@@ -73,23 +70,23 @@ yarn webiny my-custom-command "World"
 
 ## Command Definition Properties
 
-| Property | Type | Description |
-|---|---|---|
-| `name` | `string` | The command name used on the CLI (e.g., `"my-custom-command"`) |
-| `description` | `string` | Help text shown when listing commands |
-| `examples` | `string[]` | Usage examples (`$0` is replaced with the CLI binary name) |
-| `params` | `ParamDefinition[]` | Positional parameters and options |
-| `handler` | `(params: TParams) => Promise<void>` | The function that executes the command |
+| Property      | Type                                 | Description                                                    |
+| ------------- | ------------------------------------ | -------------------------------------------------------------- |
+| `name`        | `string`                             | The command name used on the CLI (e.g., `"my-custom-command"`) |
+| `description` | `string`                             | Help text shown when listing commands                          |
+| `examples`    | `string[]`                           | Usage examples (`$0` is replaced with the CLI binary name)     |
+| `params`      | `ParamDefinition[]`                  | Positional parameters and options                              |
+| `handler`     | `(params: TParams) => Promise<void>` | The function that executes the command                         |
 
 ## Parameter Definition
 
 Each param in the `params` array:
 
-| Property | Type | Description |
-|---|---|---|
-| `name` | `string` | Parameter name (matches the key in your `TParams` interface) |
-| `description` | `string` | Help text for this parameter |
-| `type` | `"string" \| "number" \| "boolean"` | Parameter value type |
+| Property      | Type                                | Description                                                  |
+| ------------- | ----------------------------------- | ------------------------------------------------------------ |
+| `name`        | `string`                            | Parameter name (matches the key in your `TParams` interface) |
+| `description` | `string`                            | Help text for this parameter                                 |
+| `type`        | `"string" \| "number" \| "boolean"` | Parameter value type                                         |
 
 ## The `Ui` Service
 
@@ -99,13 +96,13 @@ Inject `Ui` for formatted terminal output:
 import { Ui } from "webiny/cli";
 ```
 
-| Method | Description |
-|---|---|
-| `this.ui.info("message")` | Print an info message (blue) |
-| `this.ui.success("message")` | Print a success message (green) |
+| Method                       | Description                      |
+| ---------------------------- | -------------------------------- |
+| `this.ui.info("message")`    | Print an info message (blue)     |
+| `this.ui.success("message")` | Print a success message (green)  |
 | `this.ui.warning("message")` | Print a warning message (yellow) |
-| `this.ui.error("message")` | Print an error message (red) |
-| `this.ui.emptyLine()` | Print a blank line for spacing |
+| `this.ui.error("message")`   | Print an error message (red)     |
+| `this.ui.emptyLine()`        | Print a blank line for spacing   |
 
 ## Use Cases
 
@@ -129,5 +126,6 @@ Run:             yarn webiny <command-name> [args]
 
 ## Related Skills
 
-- `dependency-injection` -- The `createImplementation` pattern and available injectable services
-- `project-structure` -- How to register CLI commands in `webiny.config.tsx`
+- `webiny-dependency-injection` -- The `createImplementation` pattern and available injectable services
+- `webiny-project-structure` -- How to register CLI commands in `webiny.config.tsx`
+- `webiny-full-stack-architect` -- Full-stack extensions that may include CLI commands alongside API and Admin

package/skills/configure-auth0/SKILL.md

@@ -296,7 +296,7 @@ Both API and Admin need to be redeployed since Auth0 affects both the backend (t
 
 ## Related Skills
 
-- **configure-okta** — Alternative IDP: configuring Okta authentication
-- **dependency-injection** — The universal DI pattern used by `Auth0IdpConfig.createImplementation()`
-- **project-structure** — How `webiny.config.tsx` and extensions are organized
-- **local-development** — Deploying and testing your Auth0 configuration
+- **webiny-configure-okta** — Alternative IDP: configuring Okta authentication
+- **webiny-dependency-injection** — The universal DI pattern used by `Auth0IdpConfig.createImplementation()`
+- **webiny-project-structure** — How `webiny.config.tsx` and extensions are organized
+- **webiny-local-development** — Deploying and testing your Auth0 configuration

package/skills/configure-okta/SKILL.md

@@ -298,6 +298,6 @@ Both API and Admin need to be redeployed since Okta affects both the backend (to
 
 ## Related Skills
 
-- **dependency-injection** — The universal DI pattern used by `OktaIdpConfig.createImplementation()`
-- **project-structure** — How `webiny.config.tsx` and extensions are organized
-- **local-development** — Deploying and testing your Okta configuration
+- **webiny-dependency-injection** — The universal DI pattern used by `OktaIdpConfig.createImplementation()`
+- **webiny-project-structure** — How `webiny.config.tsx` and extensions are organized
+- **webiny-local-development** — Deploying and testing your Okta configuration