Xpersona
P

PlantUML

CLAWHUB · Unverified

Generate UML, C4, architecture, timing, ER, mindmap, WBS, and Gantt diagrams with PlantUML. Skill: PlantUML Owner: guoxh Summary: Generate UML, C4, architecture, timing, ER, mindmap, WBS, and Gantt diagrams with PlantUML. Tags: latest:1.1.1 Version history: v1.1.1 | 2026-06-13T14:42:47.400Z | user Add explicit security/trust notes for local Java/Graphviz rendering and URL-based PlantUML includes; clarify no credentials or account access are required. v1.1.0 | 2026-06-13T08:53:08.505Z | user Upgrade PlantUML

62
Rank
84
Safety
981
Downloads

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 981 downloads reported by the source. Last updated 10/11/2026.

Avoid when

  • Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Install and run

Setup complexity: low.

clawhub skill install s17dsvj6tbs3jy3xgjps2tqzn183jx3e:plantuml
  1. Setup complexity is LOW. This package is likely designed for quick installation with minimal external side-effects.
  2. Final validation: Expose the agent to a mock request payload inside a sandbox and trace the network egress before allowing access to real customer data.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-guoxh-plantuml/snapshot"

Run-check

$0.02 USD

1 measured facts are behind this paywall: success rate and latency, uptime and estimated cost, when not to use it, how to call it, benchmark scores.

Agents pay $0.02 in USDC. A card payment is $0.50, the smallest a card allows.

Documentation

CLAWHUB

66,575 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: plantuml
description: "Generate UML, C4, architecture, timing, ER, mindmap, WBS, and Gantt diagrams with PlantUML."
---

# PlantUML Diagram Generation

## One-Liner

```bash
java -jar ~/tools/plantuml.jar -tpng -charset UTF-8 file.puml
```

## Prerequisites

- **PlantUML jar:** `~/tools/plantuml.jar`
- **Graphviz:** Required for most diagram types. Verify with `dot -V`.
- **Java:** Required runtime. Verify with `java -version`.

If Graphviz is missing, sequence diagrams still render (they use the built-in lambda renderer), but other diagram types will fail.

## Security & Trust Notes

This skill is a local diagram-generation helper. It does not require credentials, account access, production data access, or background automation. It only documents how to write PlantUML source and render it with local Java/Graphviz tooling.

Rendering PlantUML executes the local PlantUML Java jar and, for most non-sequence diagrams, local Graphviz. Treat `.puml` files as source code: review diagrams before rendering when they come from untrusted input, and render inside a controlled workspace.

Most examples use PlantUML's local stdlib. A few optional icon examples in `references/stdlib-guide.md` show external `!include` URLs for AWS/Azure/devicons; those may fetch resources from GitHub at render time. For sensitive/offline environments, mirror icon libraries locally or avoid URL-based includes.

## Quick Start

1. Write `.puml` source file (kebab-case filename).
2. Generate image:
   ```bash
   java -jar ~/tools/plantuml.jar -tpng -charset UTF-8 <file>.puml
   ```
3. PlantUML uses the word after `@startuml` as the output filename (e.g., `@startuml MyDiagram` → `MyDiagram.png`).
4. Attach the resulting PNG/SVG in your reply with a `MEDIA:<absolute-path>` directive line — OpenClaw delivers it.

## Diagram Types & Syntax

- Detailed per-type syntax: [references/syntax-guide.md](references/syntax-guide.md)
- Architecture stdlib (C4, Archimate, AWS, Azure): [references/stdlib-guide.md](references/stdlib-guide.md)
- Shared style include: [references/default-style.iuml](references/default-style.iuml)
- Ready-to-render examples: [examples/](examples/)

### Use Case Diagram

```plantuml
@startuml DiagramName
left to right direction
skinparam packageStyle rectangle
skinparam actorStyle awesome

actor User
actor Admin

rectangle "System Name" {
  usecase "Login" as UC1
  usecase "Do Something" as UC2
}

User --> UC1
User --> UC2
UC2 .> UC1 : <<include>>
@enduml
```

### Class Diagram

```plantuml
@startuml DiagramName
skinparam classAttributeIconSize 0

abstract class Shape {
  + draw(): void
}
class Circle {
  - radius: double
}
Shape <|-- Circle

Circle "1" --> "0..*" Point : contains >
@enduml
```

### Sequence Diagram

```plantuml
@startuml DiagramName
actor User
participant ":System" as SYS

User -> SYS : request()
activate SYS
SYS --> User : response()
deactivate SYS

alt success
  SYS --> User : ok
else failure
  SYS --> User : error
end
@enduml
```

### Ac

_meta.json

{
  "ownerId": "kn7b21fme4bx0xwpm700dj5ehh82zrgq",
  "slug": "plantuml",
  "version": "1.1.1",
  "publishedAt": 1781361767400
}

references/stdlib-guide.md

# PlantUML Standard Library Quick Reference

PlantUML ships with curated stdlib paths usable via `!include <name>`. These produce far better-looking architecture diagrams than raw component shapes.

## C4 Model (Simon Brown)

Four zoom levels: System Context → Container → Component → Code. Use the level that matches your audience.

### System Context

```plantuml
@startuml C4Context
!include <C4/C4_Context>

title System Context — Order Platform

Person(customer, "Customer", "Places orders online.")
Person_Ext(courier, "Courier", "Delivers packages.")
System(orderSys, "Order System", "Handles ordering, billing, fulfilment.")
System_Ext(payGw, "Payment Gateway", "PCI-compliant third-party processor.")
System_Ext(emailSys, "Email Service", "Transactional email provider.")

Rel(customer, orderSys, "Places orders, tracks status")
Rel(orderSys, payGw, "Charges card", "HTTPS/JSON")
Rel(orderSys, emailSys, "Sends receipts", "SMTP")
Rel(orderSys, courier, "Dispatches shipment", "API")
@enduml
```

### Container

```plantuml
@startuml C4Container
!include <C4/C4_Container>

Person(customer, "Customer")
System_Boundary(c1, "Order System") {
  Container(web, "Web App", "React + Next.js", "Delivers SPA, server-side renders product pages.")
  Container(api, "API Service", "Node.js / Express", "Business logic, order workflow.")
  ContainerDb(db, "Order DB", "PostgreSQL 16", "Orders, customers, line items.")
  Container(worker, "Async Worker", "Node.js + BullMQ", "Email, fulfilment, retries.")
  ContainerQueue(queue, "Job Queue", "Redis Streams", "Background jobs.")
}
System_Ext(payGw, "Payment Gateway")

Rel(customer, web, "Browses, orders", "HTTPS")
Rel(web, api, "REST calls", "JSON/HTTPS")
Rel(api, db, "Reads/writes", "SQL")
Rel(api, queue, "Enqueues jobs")
Rel(worker, queue, "Consumes jobs")
Rel(api, payGw, "Charges card", "HTTPS/JSON")
@enduml
```

### Component

```plantuml
@startuml C4Component
!include <C4/C4_Component>

Container_Boundary(api, "API Service") {
  Component(orderCtl, "Order Controller", "Express Router", "HTTP handlers for /orders.")
  Component(orderSvc, "Order Service", "TypeScript class", "Order workflow, state transitions.")
  Component(payAdapter, "Payment Adapter", "TypeScript class", "Wraps Stripe/Adyen SDK.")
  Component(repo, "Order Repository", "Prisma", "Persistence layer.")
}

Rel(orderCtl, orderSvc, "Calls")
Rel(orderSvc, payAdapter, "Charge / refund")
Rel(orderSvc, repo, "CRUD")
@enduml
```

### Dynamic (sequence-style C4)

```plantuml
@startuml C4Dynamic
!include <C4/C4_Dynamic>

Person(customer, "Customer")
Container(web, "Web App", "Next.js")
Container(api, "API", "Node.js")
ContainerDb(db, "DB", "Postgres")
System_Ext(payGw, "Payment Gateway")

Rel_D(customer, web, "1. Submit checkout")
Rel_D(web, api, "2. POST /orders")
Rel_D(api, db, "3. INSERT order")
Rel_D(api, payGw, "4. Charge card")
Rel_U(payGw, api, "5. Approved")
Rel_U(api, web, "6. 201 Created")
@enduml
```

## Archimate (Enterprise Architecture)

```plantuml

references/syntax-guide.md

# PlantUML Syntax Quick Reference

## Themes

Built-in themes (set near the top of the file, after `@startuml`):

```plantuml
!theme plain               ' minimal black/white
!theme cerulean-outline    ' clean blue/white
!theme materia             ' material design
!theme spacelab            ' light, professional
!theme sketchy             ' hand-drawn look
!theme cyborg              ' dark mode
```

Full list: https://the-lum.github.io/puml-themes-gallery/

## Common Skinparam

```plantuml
skinparam classAttributeIconSize 0   ' hide visibility icons in class diagrams
skinparam packageStyle rectangle     ' rectangle-style packages
skinparam actorStyle awesome         ' stick-figure actors
skinparam defaultFontSize 12
skinparam dpi 150                    ' resolution control
skinparam shadowing false            ' disable shadows
skinparam monochrome true            ' grayscale output
skinparam backgroundColor #FFFFFF
```

For consistency, prefer the shared include:

```plantuml
!include /home/guoxh/.openclaw/skills/plantuml/references/default-style.iuml
```

## Use Case Diagram

### Actors & Use Cases
```plantuml
actor "Regular User" as User
actor Admin
usecase "Login" as UC1
usecase "Manage Users" as UC2
```

### Relationships
```plantuml
User --> UC1
UC2 .> UC1 : <<include>>     ' dashed arrow, FROM base TO included
UC3 .> UC1 : <<extend>>      ' dashed arrow, FROM extension TO base
Admin <|-- User              ' generalization (Admin inherits User)
```

### System Boundary
```plantuml
rectangle "System Name" {
  usecase "UC1" as UC1
  usecase "UC2" as UC2
}
```

## Class Diagram

### Visibility
- `+` public, `-` private, `#` protected, `~` package

### Relationships
```plantuml
ClassA <|-- ClassB              ' generalization (inheritance)
ClassA *-- ClassB               ' composition (filled diamond on A)
ClassA o-- ClassB               ' aggregation (hollow diamond on A)
ClassA --> ClassB               ' association
ClassA ..> ClassB               ' dependency (dashed)
ClassA ..|> InterfaceB          ' realization (dashed, hollow triangle)
```

### Multiplicity & Labels
```plantuml
ClassA "1" --> "0..*" ClassB : label >
```

### Abstract & Interfaces
```plantuml
abstract class Shape { }        ' name in italics
interface Drawable { }          ' <<interface>> stereotype
```

### Notes
```plantuml
note left of ClassA : Some note
note right of ClassB
  Multi-line note
end note
```

## Sequence Diagram

### Messages
```plantuml
A -> B  : synchronous call
A ->> B : asynchronous call
A --> B : return (dashed)
A -> A  : self-call
```

### Activation Bars
```plantuml
A -> B : msg
activate B
B --> A : reply
deactivate B
```

### Fragments
```plantuml
alt condition 1
  A -> B : msg1
else condition 2
  A -> B : msg2
end

opt optional condition
  A -> B : msg3
end

loop for each item
  A -> B : msg4
end

par parallel
  A -> B : msg5
else
  A -> C : msg6
end
```

### Grouping & Notes
```plantuml
group Description
  A -> B : msg
end

note left of A : note

skill-card.md

## Description:

Generate UML, C4, architecture, timing, ER, mindmap, WBS, and Gantt diagrams with PlantUML.

This skill is ready for commercial/non-commercial use.

## Publisher:

[guoxh](https://clawhub.ai/user/guoxh)

### License/Terms of Use:

MIT-0

## Use Case:

Developers and engineers use this skill to author PlantUML source for UML, C4 architecture, ER, timing, mindmap, WBS, and Gantt diagrams and render local diagram outputs with Java and Graphviz tooling.

### Deployment Geography for Use:

Global

## Known Risks and Mitigations:

Risk: Rendering untrusted .puml files runs local PlantUML and, for most non-sequence diagrams, Graphviz on diagram source.

Mitigation: Review .puml source before rendering and run untrusted diagrams in a controlled workspace.

Risk: URL-based AWS, Azure, or devicon includes can fetch mutable content from GitHub during rendering.

Mitigation: Mirror icon libraries locally or avoid URL-based includes in sensitive or offline environments.

Risk: Most non-sequence diagram types fail when Graphviz is missing or unavailable.

Mitigation: Verify Java, PlantUML, and Graphviz before use; use sequence diagrams only when Graphviz is not installed.

## Reference(s):

- [PlantUML Syntax Quick Reference](references/syntax-guide.md)
- [PlantUML Standard Library Quick Reference](references/stdlib-guide.md)
- [PlantUML Themes Gallery](https://the-lum.github.io/puml-themes-gallery/)
- [AWS Icons for PlantUML](https://github.com/awslabs/aws-icons-for-plantuml)

## Skill Output:

**Output Type(s):** [Text, Markdown, Code, Shell commands, Configuration, Guidance, Files]

**Output Format:** [Markdown guidance with PlantUML code blocks and shell commands; rendered diagram files may be PNG, SVG, PDF, EPS, TXT, or UTXT.]

**Output Parameters:** [1D]

**Other Properties Related to Output:** [Requires local Java and PlantUML tooling; Graphviz is required for most non-sequence diagram types.]

## Skill Version(s):

1.1.1 (source: server release evidence)

## Ethical Considerations:

Users should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment.

Sponsored

Ads related to PlantUML and adjacent AI workflows.