@jahia/agentic 0.0.0

package/dist/opencode/.agents/skills/jahia-content-explore-structure/SKILL.md

@@ -0,0 +1,164 @@
+---
+name: jahia-content-explore-structure
+user-invocable: false
+description: Efficiently maps an unknown Jahia website's content structure before creating or editing content. Discovers available content types, their properties (i18n vs non-i18n), valid enum values, mixin requirements, and image assets — in the minimum number of API calls. Works on any Jahia instance including fresh installs with no reference site.
+---
+
+# Skill: jahia-content-explore-structure
+
+Use this skill **before** creating content on an unfamiliar Jahia site. It produces a reusable property map so that `/jahia-content-create-content` can work without trial-and-error mutations.
+
+**No reference site required.** All content type definitions, property names, i18n flags, and enum constraints are retrieved directly from the GraphQL API via the `nodeTypeByName` and `nodeTypes` queries.
+
+---
+
+## Prerequisites
+
+- Jahia running at `http://localhost:8080`
+- Credentials: `root` / `root1234`
+- Always include `-H "Origin: http://localhost:8080"` — omitting it causes `Permission denied`
+
+---
+
+## Step 1 — Batch site exploration (ONE call)
+
+Use GraphQL aliases to retrieve everything you need in a **single HTTP request**: site metadata, page structure, file assets, and available content types.
+
+First, find the site key:
+```bash
+curl -s -u root:root1234 -H "Content-Type: application/json" -H "Origin: http://localhost:8080" \
+  -X POST http://localhost:8080/modules/graphql \
+  -d '{"query":"{ jcr { nodeByPath(path: \"/sites\") { children { nodes { name } } } } }"}'
+```
+
+Then run the full batch query (replace `SITE_KEY` and `TEMPLATE_MODULE`):
+```bash
+curl -s -u root:root1234 \
+  -H "Content-Type: application/json" -H "Origin: http://localhost:8080" \
+  -X POST http://localhost:8080/modules/graphql \
+  -d '{"query":"{ jcr { site: nodeByPath(path: \"/sites/SITE_KEY\") { properties(names: [\"j:templatesSet\",\"j:defaultLanguage\"]) { name value } } home: nodeByPath(path: \"/sites/SITE_KEY/home\") { children { nodes { name primaryNodeType { name } children { nodes { name primaryNodeType { name } } } } } } files: nodeByPath(path: \"/sites/SITE_KEY/files\") { children { nodes { name uuid } } } contentTypes: nodeTypes(filter: {siteKey: \"SITE_KEY\", includeMixins: false, includeAbstract: false}) { nodes { name systemId } } } }"}'
+```
+
+From the response:
+- `site.properties` → `j:templatesSet` (the template module name) and `j:defaultLanguage`
+- `home.children` → page area structure; look for area nodes and check their children to see which content types are in use
+- `files.children` → existing file folders and UUIDs
+- `contentTypes.nodes` → all deployed types; filter by `systemId` matching `j:templatesSet` to find the site's own types
+
+---
+
+## Step 2 — Get ALL type definitions for the template module (ONE call)
+
+Once you know `j:templatesSet` (e.g. `mymodule`) from Step 1, fetch **every type with all its properties** in a single call:
+
+```bash
+curl -s -u root:root1234 \
+  -H "Content-Type: application/json" -H "Origin: http://localhost:8080" \
+  -X POST http://localhost:8080/modules/graphql \
+  -d '{
+    "query": "{ jcr { nodeTypes(filter: {modules: [\"TEMPLATE_MODULE\"], includeMixins: false, includeAbstract: false}) { nodes { name mixin supertypes { name } properties { name requiredType internationalized mandatory multiple constraints } nodes { name mandatory requiredPrimaryType { name } } } } } }"
+  }'
+```
+
+> ✅ **This is the only type-definition call you need.** The `properties` array already includes **all inherited properties from supertypes and mixins** — the Jahia GraphQL API resolves inheritance automatically. Do **NOT** query supertypes separately, do **NOT** call `nodeTypeByName` for individual types, do **NOT** query mixin definitions.
+
+If you also need properties from standard Jahia types (e.g. `jnt:bigText`, `jnt:text`), add them with `nodeTypesByNames`:
+
+```bash
+curl -s -u root:root1234 \
+  -H "Content-Type: application/json" -H "Origin: http://localhost:8080" \
+  -X POST http://localhost:8080/modules/graphql \
+  -d '{"query":"{ jcr { nodeTypesByNames(names: [\"jnt:bigText\", \"jnt:text\"]) { name properties { name requiredType internationalized mandatory constraints } } } }"}'
+```
+
+---
+
+## Step 3 — Identify image assets
+
+File assets are already returned by the Step 1 batch query under `files.children`. No additional call needed unless you need UUIDs of files inside sub-folders:
+
+```bash
+curl -s -u root:root1234 \
+  -H "Content-Type: application/json" -H "Origin: http://localhost:8080" \
+  -X POST http://localhost:8080/modules/graphql \
+  -d '{"query":"{ jcr { nodeByPath(path: \"/sites/SITE_KEY/files/SUBFOLDER\") { children { nodes { name uuid } } } } }"}'
+```
+
+> `image` properties have `requiredType: WEAKREFERENCE`. Set them with `type: WEAKREFERENCE` and the file node UUID. The file must have `jmix:image` mixin — always include `mixins: [\"jmix:image\"]` when uploading (see `/jahia-content-create-content`).
+
+---
+
+## Step 4 — Build the property map
+
+After Step 2, summarise the data before creating content:
+
+```
+Content type: NAMESPACE:typeName
+Supertypes: [from API response — no need to query separately]
+Required mixins (must be in addNode mixins[]): jmix:renderable, jmix:internalLink, etc.
+
+Mandatory non-i18n properties (set in addNode, no language needed):
+  image          WEAKREF   UUID of jmix:image file
+
+i18n properties (set with language: "en" in mutation):
+  jcr:title      STRING    from mix:title
+  body           STRING    rich HTML text
+
+Optional non-i18n:
+  [name]         STRING    value1 | value2  (from constraints array)
+
+Mixin properties (set AFTER addNode in a separate mutation):
+  j:view         STRING    (from jmix:renderable)
+  j:linknode     WEAKREF   i18n  (from jmix:internalLink)
+  j:url          STRING    i18n  (from jmix:externalLink — set with language: "en")
+```
+
+---
+
+## Critical gotchas
+
+### 1. `j:view` cannot be set in `addNode` — set it after
+
+```graphql
+# Step 1: create node with mixin declared
+addNode(... mixins: ["jmix:renderable"] ...)
+
+# Step 2: set j:view in a separate mutation
+mutateNode(...) { mutateProperty(name: "j:view") { setValue(value: "cover") } }
+```
+
+### 2. `j:url` (from `jmix:externalLink`) requires `language: "en"` — it is an i18n property
+
+```graphql
+addNode(
+  mixins: ["jmix:externalLink"]
+  properties: [
+    {name: "j:url", type: STRING, value: "https://example.com", language: "en"}
+  ]
+)
+```
+
+### 3. GraphQL `properties()` without `language:` hides i18n property values at query time
+
+When **reading** existing nodes: use `properties(language: "en")`. When **writing** i18n properties: add `language: "en"` to the `setValue` call.
+
+---
+
+## Next step — Create content with the property map
+
+Once you have the property map from Step 4, hand it off to **`/jahia-content-create-content`**:
+
+- Use the mandatory properties list to populate `addNode` / `addChild` mutations correctly the first time
+- Use the i18n flags to know which properties need `language: "en"`
+- Use the enum constraints to pass only valid values
+- Use nested `addChild` calls to create an entire content tree in one mutation (see the `⚡ Minimum-call workflow` section in `/jahia-content-create-content`)
+
+> Skipping this skill and guessing property names leads to `ConstraintViolationException` and `Couldn't find definition for property` errors. Always explore first.
+
+---
+
+## References
+
+- GraphQL API playground: `http://localhost:8080/modules/graphql`
+- GraphQL schema introspection for node type fields: `{ __type(name: "JCRNodeType") { fields { name } } }`
+- GraphQL schema introspection for property definition fields: `{ __type(name: "JCRPropertyDefinition") { fields { name } } }`

package/dist/opencode/.agents/skills/jahia-content-move-content/SKILL.md

@@ -0,0 +1,236 @@
+---
+name: jahia-content-move-content
+description: Moves and reorganizes JCR content nodes in Jahia. Use when asked to restructure content folders, nest flat content into sections, rename or move nodes, or tidy up a content tree.
+---
+
+# Skill: jahia-content-move-content
+
+Reorganizes the JCR content tree — moving nodes into sub-folders, renaming them, and reordering them — using the Jahia GraphQL API.
+
+---
+
+## Prerequisites
+
+- Jahia running at `http://localhost:8080`
+- Credentials: `root` / `root1234` (default)
+- GraphQL endpoint: `http://localhost:8080/modules/graphql`
+
+**Always include both auth flags:**
+```bash
+curl -s -u root:root1234 \
+     -H "Content-Type: application/json" \
+     -H "Origin: http://localhost:8080" \
+     -X POST http://localhost:8080/modules/graphql \
+     -d '{"query": "..."}'
+```
+
+> ⚠️ The `Origin` header is **required** — omitting it returns `Permission denied`.
+
+---
+
+## Step 1 — Audit the current content tree
+
+Before moving anything, map out what exists and where:
+
+```bash
+# List all content folders and their direct children
+curl -s -u root:root1234 \
+  -H "Content-Type: application/json" \
+  -H "Origin: http://localhost:8080" \
+  -X POST http://localhost:8080/modules/graphql \
+  -d '{
+    "query": "{ jcr { nodeByPath(path: \"/sites/mySite/contents\") { descendants(fieldFilter: {filters: [{fieldName: \"primaryNodeType.name\", evaluation: EQUAL, value: \"jnt:contentFolder\"}]}) { nodes { path name } } } } }"
+  }'
+```
+
+Or use a JCR-SQL2 query for a flat list of all content items:
+
+```bash
+curl -s -u root:root1234 \
+  -H "Content-Type: application/json" \
+  -H "Origin: http://localhost:8080" \
+  -X POST http://localhost:8080/modules/graphql \
+  -d '{
+    "query": "{ jcr { nodesByQuery(query: \"SELECT * FROM [jnt:content] WHERE ISDESCENDANTNODE(\u0027/sites/mySite/contents\u0027) ORDER BY [jcr:path] ASC\", queryLanguage: SQL2) { nodes { path primaryNodeType { name } } } } }"
+  }'
+```
+
+---
+
+## Step 2 — Create target sub-folders
+
+If destination folders don't exist yet, create them with `mix:title` for a proper display label:
+
+```bash
+# Create a sub-folder
+curl -s -u root:root1234 \
+  -H "Content-Type: application/json" \
+  -H "Origin: http://localhost:8080" \
+  -X POST http://localhost:8080/modules/graphql \
+  -d '{
+    "query": "mutation { jcr { addNode(parentPathOrId: \"/sites/mySite/contents/articles\", name: \"getting-started\", primaryNodeType: \"jnt:contentFolder\") { node { path } } } }"
+  }'
+
+# Set a human-readable title on the folder
+curl -s -u root:root1234 \
+  -H "Content-Type: application/json" \
+  -H "Origin: http://localhost:8080" \
+  -X POST http://localhost:8080/modules/graphql \
+  -d '{
+    "query": "mutation { jcr { mutateNode(pathOrId: \"/sites/mySite/contents/articles/getting-started\") { addMixins(mixins: [\"mix:title\"]) mutateProperty(name: \"jcr:title\") { setValue(language: \"en\", value: \"Getting Started\") } } } }"
+  }'
+```
+
+---
+
+## Step 3 — Move a node
+
+Use `move` on a `mutateNode` to relocate a node to a new parent. The node keeps its name:
+
+```bash
+curl -s -u root:root1234 \
+  -H "Content-Type: application/json" \
+  -H "Origin: http://localhost:8080" \
+  -X POST http://localhost:8080/modules/graphql \
+  -d '{
+    "query": "mutation { jcr { mutateNode(pathOrId: \"/sites/mySite/contents/articles/my-article\") { move(parentPathOrId: \"/sites/mySite/contents/articles/getting-started\") } } }"
+  }'
+```
+
+> ⚠️ `move` does **not** support a `name` argument — use `rename` separately if needed.
+
+### Rename a node in place
+
+```bash
+curl -s -u root:root1234 \
+  -H "Content-Type: application/json" \
+  -H "Origin: http://localhost:8080" \
+  -X POST http://localhost:8080/modules/graphql \
+  -d '{
+    "query": "mutation { jcr { mutateNode(pathOrId: \"/sites/mySite/contents/articles\") { rename(name: \"reference-pages\") } } }"
+  }'
+```
+
+To move **and** rename, call `move` then `rename` in sequence, or combine in one mutation:
+
+```graphql
+mutation {
+  jcr {
+    mutateNode(pathOrId: "/sites/mySite/contents/articles/old-name") {
+      move(parentPathOrId: "/sites/mySite/contents/articles/getting-started")
+    }
+    rename: mutateNode(pathOrId: "/sites/mySite/contents/articles/getting-started/old-name") {
+      rename(name: "new-name")
+    }
+  }
+}
+```
+
+### Batch move with Python
+
+```python
+import subprocess, json
+
+def gql(q):
+    r = subprocess.run(["curl","-s","-u","root:root1234",
+        "-H","Origin: http://localhost:8080",
+        "-H","Content-Type: application/json",
+        "-X","POST","http://localhost:8080/modules/graphql",
+        "-d", json.dumps({"query": q})], capture_output=True, text=True)
+    d = json.loads(r.stdout)
+    if "errors" in d: print("ERR:", d["errors"][0]["message"][:80])
+    return d
+
+moves = [
+    ("/sites/mySite/contents/articles/getting-started",
+     "/sites/mySite/contents/articles/core-concepts"),
+    ("/sites/mySite/contents/articles/graphql-api",
+     "/sites/mySite/contents/articles/api-reference"),
+]
+
+for src, dest in moves:
+    r = gql(f'mutation {{ jcr {{ mutateNode(pathOrId: "{src}") {{ move(parentPathOrId: "{dest}") }} }} }}')
+    ok = "errors" not in r
+    print(f"  {'✓' if ok else '✗'} {src.split('/')[-1]} → {dest.split('/')[-1]}")
+```
+
+---
+
+## Step 4 — Reorder siblings
+
+To control the display order within a folder, use `reorder` after moving:
+
+```bash
+curl -s -u root:root1234 \
+  -H "Content-Type: application/json" \
+  -H "Origin: http://localhost:8080" \
+  -X POST http://localhost:8080/modules/graphql \
+  -d '{
+    "query": "mutation { jcr { mutateNode(pathOrId: \"/sites/mySite/contents/articles/intro\") { reorder(reorderNodes: {moveBeforeOrAfter: BEFORE, target: \"advanced\"}) } } }"
+  }'
+```
+
+---
+
+## Step 5 — Publish after moving
+
+Moving a node unpublishes it in the live workspace. Always republish after reorganizing:
+
+```bash
+# Publish a single node
+curl -s -u root:root1234 \
+  -H "Content-Type: application/json" \
+  -H "Origin: http://localhost:8080" \
+  -X POST http://localhost:8080/modules/graphql \
+  -d '{
+    "query": "mutation { jcr { mutateNode(pathOrId: \"/sites/mySite/contents/articles/getting-started/my-article\") { publish(languages: [\"en\"]) } } }"
+  }'
+
+# Publish everything under a folder at once
+curl -s -u root:root1234 \
+  -H "Content-Type: application/json" \
+  -H "Origin: http://localhost:8080" \
+  -X POST http://localhost:8080/modules/graphql \
+  -d '{
+    "query": "mutation { jcr { mutateNodesByQuery(query: \"SELECT * FROM [jnt:content] WHERE ISDESCENDANTNODE(\u0027/sites/mySite/contents\u0027)\", queryLanguage: SQL2) { publish(languages: [\"en\"]) } } }"
+  }'
+```
+
+---
+
+## Step 6 — Verify
+
+```bash
+curl -s -u root:root1234 \
+  -H "Content-Type: application/json" \
+  -H "Origin: http://localhost:8080" \
+  -X POST http://localhost:8080/modules/graphql \
+  -d '{
+    "query": "{ jcr { nodesByQuery(query: \"SELECT * FROM [jnt:content] WHERE ISDESCENDANTNODE(\u0027/sites/mySite/contents\u0027)\", queryLanguage: SQL2) { nodes { path } } } }"
+  }'
+```
+
+---
+
+## Common errors
+
+| Error | Cause | Fix |
+|-------|-------|-----|
+| `Permission denied` | Missing `Origin` header | Add `-H "Origin: http://localhost:8080"` |
+| `ItemExistsException` | A node with that name already exists at the destination | Choose a different name or use `rename` after moving |
+| `PathNotFoundException` | Source or destination path doesn't exist | Verify paths with `nodeByPath` first |
+| `move` returns `null` | Node was already at that location | Verify the current path first |
+| Content disappears from live after move | Move unpublishes — normal JCR behaviour | Run `publish` after every move |
+
+---
+
+## Workflow summary
+
+```
+1. Audit      → list current paths and types
+2. Plan       → map old paths to new paths/folders
+3. Create     → addNode for any new folders needed
+4. Move       → mutateNode { move(...) } for each item
+5. Publish    → mutateNodesByQuery { publish(...) } for all affected content
+6. Verify     → query back and confirm structure
+```

package/dist/opencode/.agents/skills/jahia-content-query-content/SKILL.md

@@ -0,0 +1,144 @@
+---
+name: jahia-content-query-content
+description: Queries JCR content from a running Jahia instance via the GraphQL API. Use when asked to list, inspect, or retrieve content nodes, check what content exists, or audit a site's content.
+---
+
+# Skill: jahia-content-query-content
+
+Retrieves JCR content from a running Jahia instance using the GraphQL JCR query API.
+
+---
+
+## Prerequisites
+
+- Jahia running at `http://localhost:8080`
+- Credentials: `root` / `root1234` (default)
+- GraphQL endpoint: `http://localhost:8080/modules/graphql`
+
+**Auth pattern — always use both flags:**
+```bash
+curl -u root:root1234 \
+     -H "Content-Type: application/json" \
+     -H "Origin: http://localhost:8080" \
+     ...
+```
+
+> ⚠️ The `Origin: http://localhost:8080` header is **required**. Requests without it return `Permission denied` even with correct credentials.
+
+---
+
+## Query patterns
+
+### 1 — Get a node by path
+
+```bash
+curl -s -u root:root1234 \
+  -H "Content-Type: application/json" \
+  -H "Origin: http://localhost:8080" \
+  -X POST http://localhost:8080/modules/graphql \
+  -d '{
+    "query": "{ jcr { nodeByPath(path: \"/sites/mySite/contents/articles\") { children { nodes { name path primaryNodeType { name } } } } } }"
+  }'
+```
+
+### 2 — Query by node type (JCR-SQL2)
+
+```bash
+curl -s -u root:root1234 \
+  -H "Content-Type: application/json" \
+  -H "Origin: http://localhost:8080" \
+  -X POST http://localhost:8080/modules/graphql \
+  -d '{
+    "query": "{ jcr { nodesByQuery(query: \"SELECT * FROM [namespace:typeName] WHERE ISDESCENDANTNODE(\u0027/sites/mySite\u0027) ORDER BY [jcr:created] DESC\", queryLanguage: SQL2) { nodes { name path uuid } } } }"
+  }'
+```
+
+### 3 — Read node properties (including i18n)
+
+```bash
+curl -s -u root:root1234 \
+  -H "Content-Type: application/json" \
+  -H "Origin: http://localhost:8080" \
+  -X POST http://localhost:8080/modules/graphql \
+  -d '{
+    "query": "{ jcr { nodeByPath(path: \"/sites/mySite/contents/articles/my-article\") { name uuid properties(language: \"en\") { name value } } } }"
+  }'
+```
+
+> ⚠️ **i18n properties require `language:` in the `properties()` call.** Without it, i18n properties are returned empty.
+
+### 4 — Filter by property value
+
+```bash
+curl -s -u root:root1234 \
+  -H "Content-Type: application/json" \
+  -H "Origin: http://localhost:8080" \
+  -X POST http://localhost:8080/modules/graphql \
+  -d '{
+    "query": "{ jcr { nodesByQuery(query: \"SELECT * FROM [namespace:article] WHERE [product] = \u0027jahia\u0027 AND ISDESCENDANTNODE(\u0027/sites/mySite\u0027)\", queryLanguage: SQL2) { nodes { name path } } } }"
+  }'
+```
+
+### 5 — List all sites
+
+```bash
+curl -s -u root:root1234 \
+  -H "Content-Type: application/json" \
+  -H "Origin: http://localhost:8080" \
+  -X POST http://localhost:8080/modules/graphql \
+  -d '{
+    "query": "{ jcr { nodesByQuery(query: \"SELECT * FROM [jnt:virtualsite] WHERE ISCHILDNODE(\u0027/sites\u0027)\", queryLanguage: SQL2) { nodes { name path } } } }"
+  }'
+```
+
+### 6 — Check publication status
+
+```bash
+curl -s -u root:root1234 \
+  -H "Content-Type: application/json" \
+  -H "Origin: http://localhost:8080" \
+  -X POST http://localhost:8080/modules/graphql \
+  -d '{
+    "query": "{ jcr { nodeByPath(path: \"/sites/mySite/contents/articles/my-article\") { name aggregatedPublicationInfo(language: \"en\") { publicationStatus } } } }"
+  }'
+```
+
+Publication status values: `PUBLISHED`, `MODIFIED`, `NOT_PUBLISHED`, `UNPUBLISHED`, `MARKED_FOR_DELETION`
+
+---
+
+## JCR-SQL2 quick reference
+
+```sql
+-- All nodes of a type under a path
+SELECT * FROM [ns:typeName] WHERE ISDESCENDANTNODE('/sites/mySite')
+
+-- Direct children only
+SELECT * FROM [ns:typeName] WHERE ISCHILDNODE('/sites/mySite/contents/articles')
+
+-- Filter by property
+SELECT * FROM [ns:typeName] WHERE [propName] = 'value'
+
+-- Order by date (newest first)
+SELECT * FROM [ns:typeName] WHERE ISDESCENDANTNODE('/sites/mySite') ORDER BY [jcr:created] DESC
+
+-- Limit results (pass limit/offset as query params)
+-- nodesByQuery(query: "...", queryLanguage: SQL2, limit: 10, offset: 0)
+```
+
+---
+
+## Common errors
+
+| Error | Cause | Fix |
+|-------|-------|-----|
+| `Permission denied` | Missing `Origin` header | Add `-H "Origin: http://localhost:8080"` |
+| i18n properties returned empty | `language:` not specified | Add `language: "en"` to `properties()` call |
+| Node not found | Wrong path or node doesn't exist | Verify path with `nodeByPath(path: "/sites")` first |
+
+---
+
+## References
+
+- Jahia GraphQL API: `http://localhost:8080/modules/graphql` (open in browser for interactive playground)
+- JCR-SQL2 language spec: https://docs.adobe.com/content/docs/en/spec/jcr/2.0/6_Query.html