@jahia/agentic 0.4.0 → 0.5.0

package/dist/claude/.claude/skills/jahia-content-translate-content/SKILL.md

@@ -1,226 +0,0 @@
----
-name: jahia-content-translate-content
-description: Adds site languages and translates existing Jahia content using MCP tools. Use when asked to enable a locale, fill in missing translations, or publish translated pages and content.
----
-
-# Skill: jahia-content-translate-content
-
-Translates existing content and manages multi-language support using MCP tools via the `jahia` MCP server.
-
-> **Never call Jahia's GraphQL API directly.** Use only MCP tools. If a capability is missing, report it — do not work around with curl/GraphQL.
-
----
-
-## Prerequisites
-
-- MCP server `jahia` connected with a valid API token
-- Know the target `siteKey` (call `site.list` if unsure)
-- Content already exists in a source locale
-
----
-
-## Step 1 — Check site languages
-
-```
-tool: site.get
-args: { "siteKey": "SITE_KEY" }
-```
-
-Check `languages` and `defaultLanguage`.
-
-- If the target locale is already present, continue.
-- If the target locale is missing, add it to the site first before writing translations.
-
----
-
-## Step 2 — Read the source content
-
-```
-tool: content.get
-args: {
-  "path": "/sites/SITE_KEY/home/about/main/intro-text",
-  "locale": "en"
-}
-```
-
-Note the properties that actually contain human-readable text.
-
-To find a batch of nodes to translate:
-
-```
-tool: content.search
-args: {
-  "siteKey": "SITE_KEY",
-  "nodeType": "jmix:droppableContent",
-  "locale": "en",
-  "limit": 50
-}
-```
-
----
-
-## Step 3 — Identify which properties are i18n
-
-```
-tool: content.type
-args: { "name": "jnt:bigText" }
-```
-
-Translate only properties marked as internationalized.
-
-Common i18n properties:
-- `jcr:title`
-- `text`
-- `body`
-- `description`
-- `subtitle`
-
-Common non-i18n properties:
-- `j:view`
-- `j:templateName`
-- `jcr:primaryType`
-- references such as `j:node`
-- numeric or technical settings
-
----
-
-## Step 4 — Write translated properties
-
-Use `content.update` with the target locale:
-
-```
-tool: content.update
-args: {
-  "path": "/sites/SITE_KEY/home/about/main/intro-text",
-  "locale": "fr",
-  "properties": {
-    "jcr:title": "À propos",
-    "text": "<p>Bienvenue sur notre site.</p>"
-  }
-}
-```
-
-Key rules:
-- Set all mandatory i18n properties in the same call.
-- Translate only i18n properties.
-- Preserve the HTML structure for rich text.
-- Do not translate technical choicelist values.
-
----
-
-## Step 5 — Translate page titles
-
-Page titles are also i18n:
-
-```
-tool: content.update
-args: {
-  "path": "/sites/SITE_KEY/home/about",
-  "locale": "fr",
-  "properties": {
-    "jcr:title": "À propos"
-  }
-}
-```
-
----
-
-## Step 6 — Verify translations
-
-Check the translated locale directly:
-
-```
-tool: content.get
-args: {
-  "path": "/sites/SITE_KEY/home/about/main/intro-text",
-  "locale": "fr"
-}
-```
-
-Or search in the target locale:
-
-```
-tool: content.search
-args: {
-  "siteKey": "SITE_KEY",
-  "nodeType": "jmix:droppableContent",
-  "locale": "fr",
-  "limit": 20,
-  "projectProperties": ["jcr:title"]
-}
-```
-
----
-
-## Step 7 — Publish the translated locale
-
-Publish the page or subtree in the target language:
-
-```
-tool: publication.publish
-args: {
-  "path": "/sites/SITE_KEY/home/about",
-  "languages": ["fr"]
-}
-```
-
-If the translation touches both a page and child content, publish the page path so the subtree is included.
-
----
-
-## Common patterns
-
-### Translate all content under a page
-
-1. Discover the page structure:
-   ```
-   tool: page.structure
-   args: { "path": "/sites/SITE_KEY/home/about" }
-   ```
-2. Read each child node in the source locale:
-   ```
-   tool: content.get
-   args: { "path": "CHILD_PATH", "locale": "en" }
-   ```
-3. Write translated values to the target locale:
-   ```
-   tool: content.update
-   args: {
-     "path": "CHILD_PATH",
-     "locale": "fr",
-     "properties": { "jcr:title": "...", "text": "..." }
-   }
-   ```
-4. Publish the page in the new language.
-
-### Audit whether a page is publish-ready in the new locale
-
-```
-tool: publication.status
-args: {
-  "path": "/sites/SITE_KEY/home/about",
-  "language": "fr",
-  "subNodes": true,
-  "references": true
-}
-```
-
----
-
-## Common errors
-
-| Error | Cause | Fix |
-|-------|-------|-----|
-| `MANDATORY_PROPERTY_MISSING` | Not all required i18n properties were set | Set all mandatory translated properties in one `content.update` call |
-| Language not available | Locale not enabled on the site | Add the locale to the site first |
-| Properties appear empty | Wrong locale was used | Verify configured locales with `site.get` |
-| Translation not visible on the public site | It is still only in EDIT | Publish with `publication.publish` |
-
----
-
-## Related skills
-
-- `/jahia-content-explore-structure` — find the right pages, nodes, and types first
-- `/jahia-content-publish` — publish translated content and inspect language-scoped status
-- `/jahia-content-create-content` — create new pages or content that will later need translation
-

package/dist/claude/.claude/skills/jahia-dev/SKILL.md

@@ -1,124 +0,0 @@
----
-name: jahia-dev
-description: Entry point for Jahia JavaScript module development. Detects your project state and tells you what to do next. Start here if you are new to the project or unsure what skill to use.
----
-
-# Jahia Dev — Project GPS
-
-You are the entry point for Jahia JavaScript module development. Your job is to assess the current project state and guide the user to the right next skill.
-
-## Step 1 — Detect project state
-
-Run all checks in parallel.
-
-### 1. Module exists?
-
-Search for a `package.json` that references `@jahia/javascript-modules-library` in the current directory or subdirectories:
-
-```bash
-find . -name "package.json" -not -path "*/node_modules/*" | xargs grep -l "@jahia/javascript-modules-library" 2>/dev/null | head -5
-```
-
-- Found → record the module name (from the `name` field in that `package.json`)
-- Not found → module does not exist yet
-
-### 2. Jahia running?
-
-```bash
-curl -s -o /dev/null -w "%{http_code}" http://localhost:8080/cms/login
-```
-
-- `200` → Jahia is running at `http://localhost:8080`
-- Anything else → Jahia is not running
-
-### 3. Content types defined?
-
-```bash
-find src/components -name "definition.cnd" 2>/dev/null | wc -l
-```
-
-Record the count of `.cnd` files found under `src/components`.
-
-### 4. Views defined?
-
-```bash
-find src/components -name "*.server.tsx" -o -name "*.client.tsx" 2>/dev/null | wc -l
-```
-
-Record the count of view files found.
-
-### 5. Page templates defined?
-
-```bash
-find src/templates/Page -type f 2>/dev/null | wc -l
-```
-
-Record the count of files in `src/templates/Page/`. More than 1 means custom templates exist (the default `index.server.tsx` is always present).
-
----
-
-## Step 2 — Report project state to user
-
-Print a clear, scannable status summary:
-
-```
-📦 Module:          ✅ <module-name> (found)   OR   ❌ not found
-🐳 Jahia:           ✅ running at http://localhost:8080   OR   ❌ not running
-📋 Content types:   <N> defined
-🖼  Views:          <N> defined
-📄 Page templates:  <N> defined
-```
-
----
-
-## Step 3 — Recommend next action
-
-Use the matrix below to pick exactly one recommendation to highlight:
-
-| Condition | Recommendation |
-|-----------|---------------|
-| No module found | 🚀 **Start here:** invoke `/jahia-dev-create-template-set` to scaffold a new Jahia JavaScript module. |
-| Module found, Jahia not running | 🐳 Your module is ready. Invoke `/jahia-dev-start-local` to start Jahia locally (Docker recommended). |
-| Module + Jahia running, 0 content types | 🎯 Jahia is running! Time to build your first component. Invoke `/jahia-dev-build-component` to create a content type + view. |
-| Module + Jahia running, content types exist, ≤1 page template | 📐 You have components. Invoke `/jahia-dev-create-page-template` to create a page template and start assembling pages. |
-| Module + Jahia running, templates exist (>1) | 🏗 Your module is taking shape! Choose what to do next (see options below). |
-
-When the last condition applies, present all options:
-
-```
-🏗 Your module is taking shape! What would you like to do next?
-  - Add a new component         → /jahia-dev-build-component
-  - Create a content listing    → /jahia-dev-query-content
-  - Review your code for issues → /jahia-dev-review
-  - Screenshot a reference site → /jahia-dev-screenshot
-  - Create a new page template  → /jahia-dev-create-page-template
-  - Clean up boilerplate        → run /jahia-dev-review and look for S10
-```
-
----
-
-## Step 4 — Print the full skill map
-
-Always print this at the end so the user can navigate anywhere:
-
-```
-## Jahia Development Skills
-
-### Setup
-/jahia-dev-create-template-set   Scaffold a new JS/React module
-/jahia-dev-start-local           Start Jahia locally (Docker or bare metal)
-
-### Building
-/jahia-dev-build-component       Build a complete component (content type + view) ← start here
-/jahia-dev-define-content-type   Define a CND content type and types.ts
-/jahia-dev-create-view           Implement a React view (.server.tsx or .client.tsx Island)
-/jahia-dev-create-page-template  Create a page template with Areas
-
-### Content
-/jahia-dev-query-content         Query JCR content with JCR-SQL2 or useJCRQuery
-
-### Quality
-/jahia-dev-review                Review code for Jahia and generic best practices
-/jahia-dev-screenshot            Screenshot reference URL + Jahia render for visual comparison
-/jahia-dev-debug                 Debug build/deploy/runtime errors end-to-end
-```

package/dist/claude/.claude/skills/jahia-dev-apis/SKILL.md

@@ -1,52 +0,0 @@
----
-name: jahia-dev-apis
-description: >
-  Jahia 8.2 developer API reference covering GraphQL, JCR Java API, RESTful JCR access,
-  OAuth/SAML authentication, personal API tokens, HTML filtering, and Content Security Policy.
-
-  Trigger this skill when the user is:
-  - Working with the Jahia GraphQL API (queries, mutations, schema extensions, Apollo client)
-  - Using the JCR Java API to read/write content nodes
-  - Accessing the RESTful JCR API or building JAX-RS endpoints
-  - Setting up OAuth 2.0 (social login) or building a custom OAuth connector
-  - Configuring SAML 2.0 authentication
-  - Using the UPA (username/password + MFA) authentication module
-  - Creating or using personal API tokens
-  - Configuring HTML filtering (XSS protection) for content properties
-  - Setting up a Content Security Policy (CSP) for a Jahia site
-  - Configuring the security filter/service (API authorization, CORS, scopes)
-  - Asking which Jahia API to use (GraphQL vs REST vs Actions)
-allowed-tools: Read
----
-
-# Jahia 8.2 Developer APIs
-
-This skill covers all developer-facing APIs and security configuration in Jahia 8.2.
-
-## Reference files
-
-| File | When to use |
-|------|-------------|
-| `references/graphql.md` | GraphQL endpoint URL, JCR queries/mutations, schema extension (SDL + Java), connection/pagination pattern, Apollo client setup, CORS and auth config |
-| `references/jcr-api.md` | Java JCR Session API (read/write nodes), auto-splitting, property interceptors, RESTful JCR access (REST endpoints, HAL+JSON), JAX-RS endpoint registration, Actions (legacy) |
-| `references/authentication.md` | OAuth 2.0 social login modules, building a custom OAuth connector, SAML 2.0 setup, UPA (username/password + MFA) module, personal API tokens (create/use/manage via Groovy) |
-| `references/security.md` | Security filter/service (scope-based authorization config), HTML filtering v2 (YAML config, strategies, workspace rules), Content Security Policy setup, JahiaUserManagerService |
-
-## Quick API overview
-
-| API | Endpoint / Access | Primary use case |
-|-----|-------------------|------------------|
-| GraphQL | `POST /modules/graphql` | Client-side apps, SPA; flexible queries, mutations, JCR node access, custom schema extension |
-| RESTful JCR | `GET/PUT/DELETE /modules/api/jcr/v1/{workspace}/{lang}/nodes/{id}` | CRUD on JCR nodes via HTTP; useful for automation scripts and server-to-server calls |
-| JAX-RS (custom REST) | Registered under `/modules/{alias}` via OSGi bundle directives | Custom REST endpoints packaged as Jahia modules |
-| JCR Java API | `JCRTemplate.getInstance().doExecuteWithSystemSession(...)` | Server-side Java code; direct node manipulation inside modules |
-| Actions | `POST /{path}.{actionName}.do` | Legacy: simple isolated server-side operations triggered from forms or rules |
-| Personal API tokens | `Authorization: APIToken <token>` header | Authenticate API calls without credentials; scoped access |
-| JWT tokens | `Authorization: Bearer <token>` header | Deprecated — use personal API tokens instead |
-
-## Key Jahia-specific concepts
-
-- **Workspaces**: `EDIT` (default) and `LIVE`. GraphQL queries default to `EDIT`; specify `jcr(workspace: LIVE)` for published content.
-- **Security filter**: All APIs (GraphQL, REST, views) are closed by default. Access is granted via scope-based config files in `karaf/etc` with pattern `org.jahia.bundles.api.authorization-*.yml`.
-- **Internationalization**: JCR sessions are opened in one language; GraphQL can query multiple languages in one call using `language:` arguments on individual fields.
-- **Session save**: Every JCR write must end with `session.save()`. In GraphQL mutations, save is automatic at the end of each `mutation { jcr }` block.