npm - @jahia/agentic - Versions diffs - 0.0.0 - Mend

@jahia/agentic 0.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (307) hide show

package/dist/gemini/.agents/skills/jahia-dev-import-from/SKILL.md ADDED Viewed

@@ -0,0 +1,244 @@
+---
+name: jahia-dev-import-from
+description: Builds a Jahia component inspired by a component on an external URL. Fetches the page, lets the developer target one section, extracts its HTML structure and CSS/JS dependencies, then creates a proper CND + view. Use when asked to "create a component like the one on this page".
+allowed-tools: Bash, Read, Write, Edit, WebFetch
+---
+# Skill: jahia-dev-import-from
+Turns a component on an external website into a Jahia component. This is a developer workflow — the result uses CSS Modules, proper Jahia architecture, and is maintainable code. It is not a wholesale site clone.
+---
+## Step 1 — Fetch and map the page
+Fetch the URL with `WebFetch`. If WebFetch fails (403/503), fall back to:
+```bash
+wget --quiet --user-agent="Mozilla/5.0" -O /tmp/imported-page.html "<URL>"
+```
+Scan the HTML for semantic section boundaries (`<section>`, `<article>`, `<header>`, `<footer>`, `<main>`, or `<div>` with class names matching patterns like `hero`, `banner`, `card`, `grid`, `slider`, `features`).
+Print a numbered text map:
+```
+[1] HEADER     — logo + nav + CTA button
+[2] HERO       — animated text + background image + scroll indicator
+[3] FEATURES   — 3-column icon grid
+[4] CAROUSEL   — auto-sliding testimonials (Swiper)
+[5] FOOTER     — 4-column links + social icons
+```
+Ask the developer: **"Which section do you want to implement?"**
+---
+## Step 2 — Extract the HTML fragment
+Locate the target section in the fetched HTML. Extract the **complete HTML block** — every element, every attribute, every nesting level. Do not simplify, summarize, or rewrite any part of it.
+**For repeating patterns** (card grid, carousel), copy the wrapper structure **plus one complete child item** with all its attributes.
+**Replace only dynamic content** with typed placeholders:
+| Source HTML | Replacement |
+|---|---|
+| Text inside an element | `{title}`, `{description}`, etc. |
+| Image `src` / `data-bg` / `data-src` URL | `{image}` (will become a `weakreference` field) |
+| Link `href` | `{href}` (will become `j:linkType` / `j:linknode`) |
+**Keep verbatim:**
+- All CSS classes
+- All `data-*` attributes (animation libraries, carousel config, IDs)
+- `aria-*` and `role` attributes
+- `<noscript>` blocks and `<picture>/<source>` elements
+- Carousel/slider wrapper `id`s — JS libraries use these for initialization
+> ⚠️ Self-check: count the attributes on 2–3 key elements in the source HTML. If your extraction has fewer, you dropped something — re-extract.
+---
+## Step 3 — Identify content fields vs structural HTML
+Show the developer a proposed split:
+**Will become CND fields (editable in Jahia):**
+- User-facing text: titles, subtitles, descriptions, button labels
+- Images (→ `weakreference, picker[type='image']`)
+- Links (→ `j:linkType / j:linknode / j:url`)
+- Any value that should vary between instances
+**Will be hardcoded in the view:**
+- Layout wrapper divs
+- Icon SVGs that are decorative / never change
+- Animation class names and `data-*` config attributes
+- ARIA labels that are structural (e.g. `aria-label="Main navigation"`)
+Ask the developer to confirm or adjust. If they want something to be editable that wasn't identified, add it as a field.
+---
+## Step 4 — Identify CSS and JS dependencies
+Scan the page `<head>` for resources that the target component depends on:
+```bash
+# From downloaded HTML, extract stylesheet and script references
+grep -E '<link[^>]+stylesheet|<script[^>]+src' /tmp/imported-page.html | head -30
+```
+Categorize findings:
+| Type | Examples | Action |
+|---|---|---|
+| **Animation library** | AOS, GSAP, ScrollReveal, Animate.css | Likely needed — check npm first |
+| **Carousel/slider** | Swiper, Glide, Owl Carousel, Splide | Likely needed — check npm first |
+| **Utility CSS** | Bootstrap, Tailwind | May already be in the module or can be imported |
+| **Site-specific CSS** | `main.css`, `theme.css` | Targeted import only (see Step 5b) |
+| **Fonts** | Google Fonts, custom woff2 | Import if not already in the module |
+Report findings, then ask: **"Should I import any of these? (yes / no / specific ones)"**
+---
+## Step 5 — Create the Jahia component
+### Step 5a — CND and view
+Using the confirmed field split from Step 3, run the `jahia-dev-define-content-type` and `jahia-dev-create-view` patterns to create:
+- `src/components/<Category>/<Name>/definition.cnd`
+- `src/components/<Category>/<Name>/types.ts`
+- `src/components/<Category>/<Name>/default.server.tsx`
+- `src/components/<Category>/<Name>/component.module.css`
+**TSX conversion rules** (mechanical, not creative):
+1. `class="foo bar"` → `className="foo bar"` — keep class strings as-is if vendor CSS is imported, OR map to `classes.fooBar` if authoring new CSS
+2. Void elements: `<img>`, `<input>`, `<br>` → add ` />`
+3. `{placeholder}` → `{propName}` matching `Props`
+4. Every `data-*`, `aria-*`, `id`, `<noscript>`, `<source>` stays in the TSX
+**CSS Modules:** Write new CSS in `component.module.css` that achieves the same visual result. Rename source class names to semantic camelCase keys (`hero__title` → `.heroTitle`). Exception: if you're importing the original CSS as a static asset, use the original class names as plain strings — CSS Modules would rename them and break the imported CSS.
+**Interactive components** (animations, carousels, event handlers) → Island architecture:
+```tsx
+// default.server.tsx — passes config, initializes nothing
+({ title, subtitle }: Props, { renderContext }) => (
+  <Island component={MyComponentClient} props={{ title, subtitle }} />
+)
+// MyComponent.client.tsx — owns the browser-side lifecycle
+import { useEffect } from "react";
+export default function MyComponentClient({ title, subtitle }: Props) {
+  useEffect(() => {
+    import("aos").then(({ default: AOS }) => AOS.init({ duration: 800 }));
+  }, []);
+  return (
+    <div data-aos="fade-up" className="hero">
+      <h1>{title}</h1>
+    </div>
+  );
+}
+```
+**Edit mode for carousels/sliders:** Render all items flat so editors can see and reorder them:
+```tsx
+({ slides }, { renderContext }) =>
+  renderContext.isEditMode() ? (
+    <div className={classes.editStack}>
+      <RenderChildren />
+      <p className={classes.hint}>Carousel — add or reorder slides above</p>
+    </div>
+  ) : (
+    <Island component={CarouselClient} props={{ count: slides?.length }} />
+  )
+```
+---
+### Step 5b — Import static assets (if confirmed in Step 4)
+For each confirmed CSS file:
+```bash
+mkdir -p static/css
+curl -sL "<css-url>" -o "static/css/<filename>.css"
+```
+For JS libraries — prefer npm over manual download:
+```bash
+# Check if available on npm
+npm info <library-name> version 2>/dev/null
+# If available:
+yarn add <library-name>
+# Then import in the .client.tsx: import AOS from "aos";
+# If not on npm, download to static:
+mkdir -p static/js
+curl -sL "<js-url>" -o "static/js/<filename>.js"
+```
+For fonts:
+```bash
+mkdir -p static/fonts
+curl -sL "<font-url>" -o "static/fonts/<filename>.woff2"
+```
+Update the module's `Layout` template (`src/templates/Layout.server.tsx` or `src/templates/Layout.jsx`) to include the assets:
+```tsx
+import { AddResources, buildModuleFileUrl } from "@jahia/javascript-modules-library";
+// In the <head> section:
+<AddResources type="css" url={buildModuleFileUrl("static/css/vendor.css")} />
+<AddResources type="javascript" url={buildModuleFileUrl("static/js/aos.js")} />
+```
+Update `package.json` → `jahia.static-resources` to expose the static directories:
+```json
+{
+  "jahia": {
+    "static-resources": "/dist/client,/dist/assets,/locales,/static/css,/static/js,/static/fonts"
+  }
+}
+```
+> **Never hardcode `/modules/<name>/...` paths** — use `buildModuleFileUrl` so the path resolves correctly across environments and module name changes.
+---
+## Step 6 — Build, deploy, and verify
+```bash
+yarn build && yarn jahia-deploy
+```
+Verify the component registered:
+```bash
+docker logs $(docker ps --format '{{.Names}}' | grep -i jahia | head -1) 2>&1 \
+  | grep "Registered Jahia component" | grep "<ComponentName>"
+```
+Expected: one line per view. If absent, check the build output for TypeScript errors in the new view file.
+---
+## Rules that always apply
+- **CSS Modules for authored styles** — use `classes.propertyName`, not plain string class names
+- **Vendor class names stay as-is** — when importing external CSS, don't route those classes through CSS Modules
+- **No hardcoded links** — `href` and `src` must come from JCR props or `buildModuleFileUrl`
+- **Island for anything interactive** — animations, browser events, `useState`, third-party JS → `.client.tsx`
+- **All props optional in `types.ts`** — even CND `mandatory` fields
+- **Edit mode awareness** — carousels, sliders, and tabs should render flat in edit mode

package/dist/gemini/.agents/skills/jahia-dev-java/SKILL.md ADDED Viewed

@@ -0,0 +1,105 @@
+---
+name: jahia-dev-java
+description: |
+  Jahia 8.2 Java module development — creating OSGi modules, defining content types (CND),
+  building JSP views, implementing backend logic (rules, actions, queries), and extending
+  the Jahia UI (Content Editor, jContent, component registry).
+  Trigger when the user is: creating or modifying a Java module, writing CND content type
+  definitions, building JSP rendering views, implementing Jahia rules or actions, running
+  JCR SQL2 queries, extending Content Editor or jContent UI, configuring OSGi services,
+  or troubleshooting module deployment issues.
+allowed-tools: Read
+---
+# Jahia 8.2 Java Developer Skill
+## When to load which reference
+| Task | Reference file |
+|------|---------------|
+| Creating a new module, Maven pom.xml, deployment, Java 11/17, static assets, deploy-free coding, troubleshooting bundle errors | `references/modules.md` |
+| Writing CND definitions, content type hierarchy, property types, choicelist initializers, modifying existing definitions | `references/content-types.md` |
+| JSP views, view selection, `@cache` tag, caching configuration, navigation menus, rendering filters, AMP | `references/rendering.md` |
+| Drools rules (DRL), JCR event listeners, JCR SQL2 queries, external data provider, permissions and roles | `references/backend.md` |
+| OSGi bundle lifecycle, Declarative Services, Blueprint XML, package Import/Export, service registry, Karaf tooling | `references/osgi.md` |
+| Content Editor JSON overrides, jContent UI extension points, component registry, custom selectors, settings pages, CKEditor | `references/ui-extensions.md` |
+## Key Concepts Glossary
+**Bundle / Module**
+An OSGi JAR deployed into Jahia. Every Jahia module is an OSGi bundle. Jahia adds custom MANIFEST attributes (`Jahia-Module-Type`, `Jahia-Depends`, `Jahia-Root-Folder`) on top of standard OSGi headers.
+**CND (Compact Namespace and Node Type Definition)**
+Apache Jackrabbit standard file format (`definitions.cnd`) that declares content types. Lives at `src/main/resources/META-INF/definitions.cnd`.
+**JCR (Java Content Repository)**
+The underlying storage model. Content is a tree of nodes, each with a primary type and optional mixin types. Jahia uses Apache Jackrabbit Oak as the JCR implementation.
+**jnt: prefix**
+Jahia Node Types namespace (`http://www.jahia.org/jahia/nt/1.0`). Used for concrete content types like `jnt:content`, `jnt:page`, `jnt:file`.
+**jmix: prefix**
+Jahia Mixin namespace (`http://www.jahia.org/jahia/mix/1.0`). Used for abstract mixin types like `jmix:editorialContent`, `jmix:list`, `jmix:cache`.
+**jmix:editorialContent**
+Key mixin — makes a content type visible in jContent and enables content versioning. Required for any user-editable content type.
+**jmix:droppableContent**
+Base mixin for component categories. Types that inherit from this mixin create a component folder in the content picker sidebar.
+**Declarative Services (DS)**
+Preferred OSGi service mechanism in Jahia 8.2. Uses `@Component`, `@Activate`, `@Reference` annotations. Blueprint XML is deprecated as of Jahia 8.2.
+**jahia-depends**
+MANIFEST / pom.xml property declaring other module artifact IDs that this module requires. OSGi resolves dependencies before starting the bundle. Supports version ranges and optional dependencies.
+**Embed-Dependency**
+Felix Maven Bundle Plugin instruction to embed non-OSGi JARs inside the module JAR. Default scope: `compile|runtime`. Dependencies scoped `provided` are NOT embedded.
+**Deploy-free coding**
+Development workflow where source file changes (JSP, CSS, JS, CND) are picked up live without redeployment. Requires initial deploy and `Jahia-Source-Folders` MANIFEST attribute pointing to the project base directory.
+**jahia:deploy Maven goal**
+Deploys the compiled module JAR to a local Jahia server or Docker container. Usage: `mvn clean install jahia:deploy -P <profile>`.
+**Content Editor**
+Jahia's React-based form UI for creating/editing content. Forms are generated from CND definitions merged with JSON override files. Override files live in `META-INF/jahia-content-editor-forms/`.
+**jContent**
+Jahia's React-based content management UI. Extended via the component registry (`window.jahia.uiExtender.registry`). Used by editors to browse, create, and manage content.
+**Component Registry**
+JavaScript hashmap (`type + key → value`) used to inject UI elements (actions, accordions, nav items, selector types) into jContent and Content Editor at runtime. Access via `import {registry} from '@jahia/ui-extender'`.
+**DRL (Drools Rule Language)**
+Rule files placed at `META-INF/rules.drl` (all workspaces), `META-INF/default-rules.drl` (edit workspace only), or `META-INF/live-rules.drl` (live workspace only). Jahia provides a built-in DSL that simplifies rule conditions and consequences.
+**Workspace**
+Jahia has two JCR workspaces: `default` (edit/preview, where authors work) and `live` (what visitors see). Publication copies nodes from default to live.
+**Felix Web Console**
+OSGi administration UI at `http://localhost:8080/tools`. Shows bundle states, packages, services. Useful for diagnosing dependency issues.
+**Karaf SSH Shell**
+Command-line OSGi console accessible via `ssh -p 8101 jahia@localhost`. Key commands: `jahia:modules`, `bundle:requirements`, `jcr:query`.
+**JCR SQL2**
+Query language for the JCR. Syntax: `SELECT * FROM [nodetype] AS alias WHERE condition`. Use `ISDESCENDANTNODE(alias, '/path')` to scope queries. Do NOT query `nt:base` — use `jmix:searchable` instead for broad content queries.
+**choicelist initializer**
+Java class implementing `ModuleChoiceListInitializer` that populates dropdown values in Content Editor. Registered as an OSGi `@Component` service. Referenced in CND with `choicelist[keyName]` syntax.
+**Rendering filter**
+OSGi service implementing `RenderFilter`. Wraps every JSP/module render. Priority < 16 runs per-request; priority > 16 runs only on cache miss. Extend `AbstractFilter` to use condition setters.
+**Migration scripts**
+Groovy scripts in `src/main/resources/META-INF/patches/` that run once on module deployment to migrate JCR content or configuration.
+**Module types**
+`Jahia-Module-Type` MANIFEST value controls module behavior:
+- `module` — regular content module (default)
+- `system` — loaded early, provides system-level services
+- `templatesSet` — template set module that defines site templates
+**Static resources**
+JS/CSS/images declared in `Jahia-Static-Resources` MANIFEST header (e.g. `/css,/icons,/javascript`). Served directly from the OSGi bundle JAR under `src/main/resources/`.

package/dist/gemini/.agents/skills/jahia-dev-java/references/backend.md ADDED Viewed

@@ -0,0 +1,331 @@
+# Jahia Backend Capabilities Reference
+## Table of Contents
+1. [Drools rule engine](#1-drools-rule-engine)
+2. [JCR event listeners](#2-jcr-event-listeners)
+3. [JCR SQL2 cheat sheet](#3-jcr-sql2-cheat-sheet)
+4. [Queries and search indexing](#4-queries-and-search-indexing)
+5. [External data sources (Provider API)](#5-external-data-sources-provider-api)
+6. [Permissions and roles](#6-permissions-and-roles)
+---
+## 1. Drools rule engine
+Jahia uses JBoss Drools 6 for a rules engine that reacts to JCR events.
+### Rule file locations
+| File | Scope |
+|------|-------|
+| `META-INF/rules.drl` | All workspaces (default and live) |
+| `META-INF/default-rules.drl` | Edit/preview workspace only |
+| `META-INF/live-rules.drl` | Live workspace only |
+| `META-INF/rules.dsl` | Custom DSL extensions |
+### Basic rule structure
+```drools
+package org.example.mymodule.rules
+import org.jahia.services.content.rules.*
+import org.jahia.services.content.JCRContentUtils
+import org.slf4j.Logger
+global User user
+global Service service
+global Logger logger
+global MyService myService
+rule "Log new article creation"
+    when
+        A new node is created
+        - the node has the type jnt:article
+    then
+        Log "New article created: " + node.getName() at INFO level
+end
+rule "Notify on page publish"
+    salience 100
+    when
+        A node is published
+        - the node has the type jnt:page
+    then
+        myService.notifyPublish(node)
+end
+```
+**Critical rules:** Rule titles are globally unique across the platform — never reuse rule names between modules.
+**Package names:** Use a unique package per module — do not share package names across modules.
+### Built-in DSL conditions (excerpt)
+```drools
+A new node is created             # AddedNodeFact
+A node is published               # PublishedNodeFact
+A node is deleted                 # DeletedNodeFact
+A node is modified                # ChangedPropertyFact
+- the node has the type {type}    # Checks primaryType or mixin
+```
+### Built-in global objects
+| Global | Type | Description |
+|--------|------|-------------|
+| `user` | `org.jahia.services.content.rules.User` | Current user context |
+| `service` | `org.jahia.services.content.rules.Service` | Core JCR service shortcuts |
+| `logger` | `org.slf4j.Logger` | SLF4J logger |
+| `imageService` | `org.jahia.services.content.rules.ImageService` | Image operations |
+| `extractionService` | `org.jahia.services.content.rules.ExtractionService` | Content extraction |
+### Registering a custom service as a rules global
+Step 1 — Declare the service component:
+```java
+@Component(service = MyService.class)
+public class MyService {
+    public void doSomething(AddedNodeFact node) throws RepositoryException { }
+}
+```
+Step 2 — Register as a global rules object:
+```java
+@Component(service = ModuleGlobalObject.class)
+public class MyRulesGlobalObjects extends ModuleGlobalObject {
+    @Reference
+    public void setMyService(MyService myService) {
+        getGlobalRulesObject().put("myService", myService);
+    }
+    public void unsetMyService(MyService myService) {
+        getGlobalRulesObject().remove("myService");
+    }
+}
+```
+Step 3 — Declare global and import in rules.drl:
+```drools
+import org.example.mymodule.MyService
+global MyService myService
+```
+**Important:** Export the package containing `MyService` so other modules can import it in DRL files.
+### Custom DSL extensions (rules.dsl)
+```drools
+[condition][]A new article is created=node : AddedNodeFact (types contains "jnt:article")
+[consequence][]Notify publish for {node}=myService.notifyPublish({node});
+```
+---
+## 2. JCR event listeners
+Extend `DefaultEventListener` to react to JCR node events:
+```java
+public class MyJCREventListener extends DefaultEventListener {
+    @Override
+    public int getEventTypes() {
+        return Event.NODE_ADDED | Event.NODE_REMOVED | Event.PROPERTY_CHANGED;
+    }
+    @Override
+    public String getPath() {
+        return "/sites";
+    }
+    @Override
+    public void onEvent(EventIterator events) {
+        while (events.hasNext()) {
+            Event event = events.nextEvent();
+            try {
+                String path = event.getPath();
+            } catch (RepositoryException e) {
+                logger.error("Error processing event", e);
+            }
+        }
+    }
+}
+```
+**JCR Event types:** `Event.NODE_ADDED`, `Event.NODE_REMOVED`, `Event.PROPERTY_ADDED`, `Event.PROPERTY_CHANGED`, `Event.PROPERTY_REMOVED`, `Event.NODE_MOVED`
+---
+## 3. JCR SQL2 cheat sheet
+JCR SQL2 syntax: `SELECT * FROM [nodeType] AS alias WHERE conditions ORDER BY alias.[prop]`
+### Querying node types
+```sql
+-- Prefer jmix:searchable over nt:base for broad queries
+SELECT * FROM [jmix:searchable] AS node
+SELECT * FROM [jnt:page] AS page
+SELECT * FROM [jnt:file] AS file
+SELECT * FROM [jnt:article] AS article
+```
+### Path constraints (always include for performance)
+```sql
+SELECT * FROM [jnt:article] AS node
+WHERE ISDESCENDANTNODE(node, '/sites/mySite')
+SELECT * FROM [jnt:page] AS child
+WHERE ISCHILDNODE(child, '/sites/mySite/home')
+```
+### String matching
+```sql
+SELECT * FROM [jnt:content] AS node WHERE node.[jcr:title] = 'My Title'
+SELECT * FROM [jnt:content] AS node WHERE node.[jcr:title] LIKE '%news%'
+SELECT * FROM [jnt:page] AS node WHERE LOWER(node.[jcr:title]) = 'home'
+SELECT * FROM [jnt:page] AS page WHERE page.[jcr:title] IS NOT NULL
+SELECT * FROM [jnt:content] AS node WHERE CONTAINS(node.*, 'digital')
+```
+### Property and type queries
+```sql
+SELECT * FROM [jnt:page] AS page WHERE page.[j:published] > CAST('true' AS BOOLEAN)
+SELECT * FROM [jnt:page] AS page
+WHERE page.[j:published] > CAST('2021-01-01T00:00:01.000Z' AS DATE)
+```
+### Ordering and templates
+```sql
+SELECT * FROM [jnt:page] AS page ORDER BY page.[j:lastModified] DESC
+SELECT * FROM [jnt:page] AS page WHERE page.[j:templateName] = 'home'
+```
+### Non-query lookups (use instead of queries for performance)
+```java
+// By UUID (preferred over UUID query)
+session.getNodeByIdentifier("the-uuid-string");
+// Set result limit (no LIMIT keyword in JCR SQL2)
+QueryObjectModelImpl qom = ...;
+qom.setLimit(20);
+qom.setOffset(0);
+```
+---
+## 4. Queries and search indexing
+### Executing a JCR SQL2 query in Java
+```java
+JCRSessionWrapper session = JCRSessionFactory.getInstance()
+    .getCurrentUserSession("default", Locale.ENGLISH);
+QueryManager queryManager = session.getWorkspace().getQueryManager();
+Query query = queryManager.createQuery(
+    "SELECT * FROM [jnt:article] WHERE ISDESCENDANTNODE('/sites/mySite')",
+    Query.JCR_SQL2
+);
+QueryResult result = query.execute();
+NodeIterator nodes = result.getNodes();
+while (nodes.hasNext()) {
+    JCRNodeWrapper node = (JCRNodeWrapper) nodes.nextNode();
+}
+```
+### Index tuning via CND keywords
+```cnd
+- title (string) i18n boost=3.0          # Higher search relevance
+- code (string) analyzer=keyword          # Index as single token
+- internalNotes (string) nofulltext       # Indexed but not in full-text search
+- binaryData (binary) indexed=no          # Not indexed at all
+- category (string) facetable            # Enables faceted search
+```
+---
+## 5. External data sources (Provider API)
+The External Provider API allows exposing non-JCR data as virtual JCR nodes.
+### Key interfaces
+| Interface | Purpose |
+|-----------|---------|
+| `ExternalDataSource` | Main interface to implement for external data |
+| `ExternalDataSource.Searchable` | Add search support |
+| `ExternalDataSource.Writable` | Add write support |
+| `ExternalContentStoreProvider` | OSGi service to mount the provider |
+### Minimal ExternalDataSource implementation
+```java
+@Component(service = ExternalDataSource.class)
+public class MyExternalDataSource implements ExternalDataSource {
+    @Override
+    public List<String> getChildren(String path) throws PathNotFoundException {
+        return Arrays.asList("item1", "item2");
+    }
+    @Override
+    public ExternalData getItemByPath(String path) throws PathNotFoundException {
+        ExternalData data = new ExternalData("unique-id", path, "jnt:content",
+            new HashMap<String, String[]>());
+        data.getProperties().put("jcr:title", new String[]{"My Title"});
+        return data;
+    }
+    @Override
+    public ExternalData getItemByIdentifier(String identifier) throws ItemNotFoundException {
+        return null;
+    }
+    @Override
+    public Set<String> getSupportedNodeTypes() {
+        return Collections.singleton("jnt:content");
+    }
+    @Override public boolean isSupportsUuid() { return false; }
+    @Override public boolean isSupportsHierarchicalIdentifiers() { return false; }
+    @Override public boolean itemExists(String path) { return true; }
+}
+```
+---
+## 6. Permissions and roles
+### Permission hierarchy
+| Level | Description |
+|-------|-------------|
+| Server level | Global roles (e.g., Server Administrator) |
+| Site level | Site-specific roles (e.g., Site Administrator, Editor) |
+| Node level | Per-node ACL inheritance |
+### Checking permissions in code
+```java
+if (currentNode.hasPermission("jcr:write")) { }
+// In JSP
+<c:if test="${jcr:hasPermission(currentNode, 'jcr:write')}">...</c:if>
+```
+### Standard JCR permissions
+| Permission | Description |
+|------------|-------------|
+| `jcr:read` | Read node and properties |
+| `jcr:write` | Modify properties and children |
+| `jcr:addChildNodes` | Add child nodes |
+| `jcr:removeNode` | Delete the node |
+| `jcr:modifyProperties` | Modify properties |