Add asset-registry validate command

Add `asset-registry validate --assetType X` that proxies to the new
Pacman validate endpoint (POST /core/asset-registry/validate/{assetType}).

Accepts --body for inline JSON or -f for a JSON file.

Update SKILL.md, agentic guide, and command docs.

Includes-AI-Code: true
Made-with: Cursor

Author: ZgjimHaziri

.cursor/skills/asset-registry-endpoints/SKILL.md

@@ -223,20 +223,44 @@ methodology — a 404 means the endpoint is not available.
 $CLI asset-registry methodology --assetType <ASSET_TYPE> -p <profile>
 ```
 
-### Validate (POST — via config import)
+### Validate (POST)
 
-Use `config import --validate` to validate assets against their schema before
-importing:
+Validate asset configurations against the asset service's validation endpoint.
+The request body follows the `ValidateRequest` schema:
+
+```json
+{
+  "assetType": "BOARD_V2",
+  "packageKey": "my-pkg",
+  "nodes": [
+    { "key": "my-view", "configuration": { ... } }
+  ]
+}
+```
+
+Inline:
 
 ```bash
-$CLI config import -d <export_dir> --validate --overwrite -p <profile>
+$CLI asset-registry validate --assetType <ASSET_TYPE> --body '<json>' -p <profile>
+```
+
+From file:
+
+```bash
+$CLI asset-registry validate --assetType <ASSET_TYPE> -f request.json -p <profile>
 ```
 
 **Important**: If validation returns errors, do **not** proceed with the import.
-Instead, fix the schema violations in the node JSON and re-run the command. If
-you cannot resolve the errors automatically, present the validation results to
-the user and ask whether they want to continue importing with invalid
-configuration or stop to fix it manually.
+Instead, fix the schema violations in the node JSON and re-validate. If you
+cannot resolve the errors automatically, present the validation results to the
+user and ask whether they want to continue importing with invalid configuration
+or stop to fix it manually.
+
+You can also validate during import with `config import --validate`:
+
+```bash
+$CLI config import -d <export_dir> --validate --overwrite -p <profile>
+```
 
 ## Troubleshooting
 
@@ -284,6 +308,7 @@ $CLI config import -d <export_dir> --validate --overwrite -p <profile>
 | `asset-registry list` | List all registered asset types |
 | `asset-registry get --assetType X` | Get the full descriptor for an asset type |
 | `asset-registry schema --assetType X` | Get the JSON Schema for the asset's configuration |
+| `asset-registry validate --assetType X --body/​-f` | Validate asset configurations against the asset service |
 | `asset-registry examples --assetType X` | Get example configurations (if available) |
 | `asset-registry methodology --assetType X` | Get methodology / best-practices (if available) |
 | `config list` | List packages |

docs/user-guide/agentic-development-guide.md

@@ -73,15 +73,26 @@ Add a new JSON file in the `nodes/` directory:
 
 Set `schemaVersion` to the value from the asset descriptor's `assetSchema.version` field (returned by `asset-registry get`). The `spaceId` is required — omitting it causes import errors.
 
-### 5. Validate and import
+### 5. Validate
+
+Before importing, validate the asset configuration:
+
+```bash
+content-cli asset-registry validate --assetType <ASSET_TYPE> \
+  --body '{"assetType":"<ASSET_TYPE>","packageKey":"<pkg>","nodes":[{"key":"<key>","configuration":{...}}]}'
+```
+
+Or validate during import with the `--validate` flag:
 
 ```bash
 content-cli config import -d <export_dir> --validate --overwrite
 ```
 
-The `--validate` option performs schema validations for the assets. If there are no schema validations, then the package and its assets are imported. Otherwise, the validation errors are returned and the package import isn't performed.
+If validation returns errors, fix the issues before importing.
+
+### 6. Import
 
-This creates a new version in staging (not deployed) if there are no schema validation errors. To create a brand-new package instead of updating, omit `--overwrite`.
+This creates a new version in staging (not deployed). To create a brand-new package instead of updating, omit `--overwrite`.
 
 To later export a staging version, use `--keysByVersion`:
 

docs/user-guide/asset-registry-commands.md

@@ -71,6 +71,29 @@ Options:
 - `--assetType <assetType>` (required) – The asset type identifier
 - `--json` – Write the schema to a JSON file in the working directory
 
+## Validate
+
+Validate asset configurations against the asset service's validation endpoint. The request body must follow the `ValidateRequest` format expected by the asset service.
+
+Using inline JSON:
+
+```
+content-cli asset-registry validate --assetType BOARD_V2 --body '{"assetType":"BOARD_V2","packageKey":"my-pkg","nodes":[{"key":"my-view","configuration":{}}]}'
+```
+
+Using a JSON file:
+
+```
+content-cli asset-registry validate --assetType BOARD_V2 -f request.json
+```
+
+Options:
+
+- `--assetType <assetType>` (required) – The asset type identifier
+- `--body <body>` – Validation request body as inline JSON
+- `-f, --file <file>` – Path to a JSON file containing the validation request body
+- `--json` – Write the validation response to a JSON file in the working directory
+
 ## Get Examples
 
 Fetch example configurations for an asset type. Not all asset types provide examples.

src/commands/asset-registry/asset-registry-api.ts

@@ -42,6 +42,14 @@ export class AssetRegistryApi {
             });
     }
 
+    public async validate(assetType: string, body: any): Promise<any> {
+        return this.httpClient()
+            .post(`/pacman/api/core/asset-registry/validate/${encodeURIComponent(assetType)}`, body)
+            .catch((e) => {
+                throw new FatalError(`Problem validating asset type '${assetType}': ${e}`);
+            });
+    }
+
     public async getMethodology(assetType: string): Promise<any> {
         return this.httpClient()
             .get(`/pacman/api/core/asset-registry/methodologies/${encodeURIComponent(assetType)}`)

src/commands/asset-registry/asset-registry.service.ts

@@ -2,8 +2,9 @@ import { AssetRegistryApi } from "./asset-registry-api";
 import { AssetRegistryDescriptor } from "./asset-registry.interfaces";
 import { Context } from "../../core/command/cli-context";
 import { fileService, FileService } from "../../core/utils/file-service";
-import { logger } from "../../core/utils/logger";
+import { FatalError, logger } from "../../core/utils/logger";
 import { v4 as uuidv4 } from "uuid";
+import * as fs from "fs";
 
 export class AssetRegistryService {
     private api: AssetRegistryApi;
@@ -53,6 +54,12 @@ export class AssetRegistryService {
         this.outputResponse(data, jsonResponse);
     }
 
+    public async validate(assetType: string, body?: string, file?: string, jsonResponse?: boolean): Promise<void> {
+        const payload = this.resolveBody(body, file);
+        const data = await this.api.validate(assetType, payload);
+        this.outputResponse(data, !!jsonResponse);
+    }
+
     public async getMethodology(assetType: string, jsonResponse: boolean): Promise<void> {
         const data = await this.api.getMethodology(assetType);
         this.outputResponse(data, jsonResponse);
@@ -93,4 +100,20 @@ export class AssetRegistryService {
             logger.info(`  examples:   ${descriptor.endpoints.examples}`);
         }
     }
+
+    private resolveBody(body?: string, file?: string): any {
+        if (!body && !file) {
+            throw new FatalError("Provide either --body (inline JSON) or -f (path to JSON file).");
+        }
+        if (body && file) {
+            throw new FatalError("Provide either --body or -f, not both.");
+        }
+
+        const raw = file ? fs.readFileSync(file, "utf-8") : body!;
+        try {
+            return JSON.parse(raw);
+        } catch {
+            throw new FatalError("Request body must be valid JSON.");
+        }
+    }
 }

src/commands/asset-registry/module.ts

@@ -32,6 +32,14 @@ class Module extends IModule {
             .option("--json", "Return the response as a JSON file")
             .action(this.getExamples);
 
+        assetRegistryCommand.command("validate")
+            .description("Validate asset configuration against the asset service")
+            .requiredOption("--assetType <assetType>", "The asset type identifier (e.g., BOARD_V2)")
+            .option("--body <body>", "Validation request body as inline JSON")
+            .option("-f, --file <file>", "Path to a JSON file containing the validation request body")
+            .option("--json", "Return the response as a JSON file")
+            .action(this.validate);
+
         assetRegistryCommand.command("methodology")
             .description("Get the methodology / best-practices guide for an asset type")
             .requiredOption("--assetType <assetType>", "The asset type identifier (e.g., BOARD_V2)")
@@ -51,6 +59,10 @@ class Module extends IModule {
         await new AssetRegistryService(context).getSchema(options.assetType, !!options.json);
     }
 
+    private async validate(context: Context, command: Command, options: OptionValues): Promise<void> {
+        await new AssetRegistryService(context).validate(options.assetType, options.body, options.file, !!options.json);
+    }
+
     private async getExamples(context: Context, command: Command, options: OptionValues): Promise<void> {
         await new AssetRegistryService(context).getExamples(options.assetType, !!options.json);
     }

tests/commands/asset-registry/asset-registry-module.spec.ts

@@ -19,6 +19,7 @@ describe("Asset Registry Module", () => {
             listTypes: jest.fn().mockResolvedValue(undefined),
             getType: jest.fn().mockResolvedValue(undefined),
             getSchema: jest.fn().mockResolvedValue(undefined),
+            validate: jest.fn().mockResolvedValue(undefined),
             getExamples: jest.fn().mockResolvedValue(undefined),
             getMethodology: jest.fn().mockResolvedValue(undefined),
         } as any;
@@ -33,6 +34,18 @@ describe("Asset Registry Module", () => {
         expect(mockService.getSchema).toHaveBeenCalledWith("BOARD_V2", true);
     });
 
+    it("should call validate with correct parameters", async () => {
+        const options: OptionValues = { assetType: "BOARD_V2", body: '{"nodes":[]}', json: "" };
+        await (module as any).validate(testContext, mockCommand, options);
+        expect(mockService.validate).toHaveBeenCalledWith("BOARD_V2", '{"nodes":[]}', undefined, false);
+    });
+
+    it("should call validate with file option", async () => {
+        const options: OptionValues = { assetType: "BOARD_V2", file: "request.json", json: true };
+        await (module as any).validate(testContext, mockCommand, options);
+        expect(mockService.validate).toHaveBeenCalledWith("BOARD_V2", undefined, "request.json", true);
+    });
+
     it("should call getExamples with correct parameters", async () => {
         const options: OptionValues = { assetType: "BOARD_V2", json: "" };
         await (module as any).getExamples(testContext, mockCommand, options);

tests/commands/asset-registry/asset-registry-validate.spec.ts

@@ -0,0 +1,107 @@
+import { mockAxiosPost } from "../../utls/http-requests-mock";
+import { AssetRegistryService } from "../../../src/commands/asset-registry/asset-registry.service";
+import { testContext } from "../../utls/test-context";
+import { loggingTestTransport, mockWriteFileSync } from "../../jest.setup";
+import { FileService } from "../../../src/core/utils/file-service";
+import * as path from "path";
+import * as fs from "fs";
+
+jest.mock("fs", () => ({
+    ...jest.requireActual("fs"),
+    readFileSync: jest.fn(),
+}));
+
+describe("Asset registry validate", () => {
+    const validateResponse = {
+        valid: false,
+        diagnostics: [
+            {
+                severity: "ERROR",
+                nodeKey: "my-view",
+                assetType: "BOARD_V2",
+                path: "$.components[0].type",
+                code: "INVALID_ENUM_VALUE",
+                message: "Invalid component type",
+            },
+        ],
+    };
+
+    const requestBody = {
+        assetType: "BOARD_V2",
+        packageKey: "my-pkg",
+        nodes: [{ key: "my-view", configuration: { components: [{ type: "bad" }] } }],
+    };
+
+    it("Should validate with inline body and print result", async () => {
+        mockAxiosPost(
+            "https://myTeam.celonis.cloud/pacman/api/core/asset-registry/validate/BOARD_V2",
+            validateResponse
+        );
+
+        await new AssetRegistryService(testContext).validate(
+            "BOARD_V2", JSON.stringify(requestBody), undefined, false
+        );
+
+        expect(loggingTestTransport.logMessages.length).toBe(1);
+        const output = loggingTestTransport.logMessages[0].message;
+        expect(output).toContain("INVALID_ENUM_VALUE");
+        expect(output).toContain("my-view");
+    });
+
+    it("Should validate with inline body and save as JSON file", async () => {
+        mockAxiosPost(
+            "https://myTeam.celonis.cloud/pacman/api/core/asset-registry/validate/BOARD_V2",
+            validateResponse
+        );
+
+        await new AssetRegistryService(testContext).validate(
+            "BOARD_V2", JSON.stringify(requestBody), undefined, true
+        );
+
+        const expectedFileName = loggingTestTransport.logMessages[0].message.split(FileService.fileDownloadedMessage)[1];
+        expect(mockWriteFileSync).toHaveBeenCalledWith(
+            path.resolve(process.cwd(), expectedFileName),
+            expect.any(String),
+            { encoding: "utf-8" }
+        );
+
+        const written = JSON.parse(mockWriteFileSync.mock.calls[0][1]);
+        expect(written.valid).toBe(false);
+        expect(written.diagnostics[0].code).toBe("INVALID_ENUM_VALUE");
+    });
+
+    it("Should validate with body from file", async () => {
+        (fs.readFileSync as jest.Mock).mockReturnValue(JSON.stringify(requestBody));
+
+        mockAxiosPost(
+            "https://myTeam.celonis.cloud/pacman/api/core/asset-registry/validate/BOARD_V2",
+            validateResponse
+        );
+
+        await new AssetRegistryService(testContext).validate(
+            "BOARD_V2", undefined, "request.json", false
+        );
+
+        expect(fs.readFileSync).toHaveBeenCalledWith("request.json", "utf-8");
+        expect(loggingTestTransport.logMessages.length).toBe(1);
+        expect(loggingTestTransport.logMessages[0].message).toContain("INVALID_ENUM_VALUE");
+    });
+
+    it("Should throw when neither body nor file is provided", async () => {
+        await expect(
+            new AssetRegistryService(testContext).validate("BOARD_V2", undefined, undefined, false)
+        ).rejects.toThrow("Provide either --body (inline JSON) or -f (path to JSON file).");
+    });
+
+    it("Should throw when both body and file are provided", async () => {
+        await expect(
+            new AssetRegistryService(testContext).validate("BOARD_V2", "{}", "file.json", false)
+        ).rejects.toThrow("Provide either --body or -f, not both.");
+    });
+
+    it("Should throw when body is not valid JSON", async () => {
+        await expect(
+            new AssetRegistryService(testContext).validate("BOARD_V2", "not-json{", undefined, false)
+        ).rejects.toThrow("Request body must be valid JSON.");
+    });
+});