Skip to content
Back to search

strataglyph

MarketplaceWorks with Claude CodeGitHub

🗺️ Turn YAML into animated cloud architecture diagrams. Export SVG, PNG, draw.io, React, or HTML through the CLI or an MCP client.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 19 Nov 2026. Its scripts were only partly scanned.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/ATLURI0001/StrataGlyph with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/ATLURI0001/StrataGlyph'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/atluri0001--strataglyph/badge.svg)](/listings/atluri0001--strataglyph)

HTML

<a href="/listings/atluri0001--strataglyph"><img src="/api/listings/atluri0001--strataglyph/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

From this checkout, run `node skills/strataglyph/scripts/strataglyph.mjs doctor`. Scoped npm commands require a release under `@atluri0001/strataglyph`.

Claude Code plugin:

/plugin marketplace add ATLURI0001/strataglyph
/plugin install strataglyph@strataglyph

Any agent that reads [Agent Skills](https://agentskills.io) (Codex, Cursor, Gemini CLI, Kiro and others):

npx skills add ATLURI0001/strataglyph
gh skill install ATLURI0001/strataglyph strataglyph              # GitHub CLI, any supported agent
gemini extensions install https://github.com/ATLURI0001/strataglyph   # Gemini CLI extension

Only the CLI, from npm:

npx @atluri0001/strataglyph doctor
npx @atluri0001/strataglyph render diagram.yaml -f all --theme both

Or from a clone: `node strataglyph/skills/strataglyph/scripts/strataglyph.mjs doctor`.

As an MCP server, for any client that speaks the Model Context Protocol (tools: authoring guide, validate, render, review, icon search, templates, patch candidates, draw.io link):

{ "mcpServers": { "strataglyph": { "command": "npx", "args": ["-y", "@atluri0001/strataglyph", "mcp"] } } }

That block goes in `.mcp.json` for Claude Code, `~/.gemini/settings.json` for Gemini CLI, `.cursor/mcp.json` for Cursor and `.kiro/settings/mcp.json` for Kiro; Codex takes `[mcp_servers.strataglyph]` with `command = "npx"` and `args = ["-y", "@atluri0001/strataglyph", "mcp"]` in `~/.codex/config.toml`. `strataglyph mcp install <client>` writes that entry for you (`claude-code`, `claude-desktop`, `cursor`, `vscode`, `gemini`, `codex` or `kiro`, in the project or with `user` for every project), keeping every other server in the file. Each release publishes the server to the MCP Registry as `io.github.ATLURI0001/strataglyph` and attaches an `.mcpb` bundle for one-click install in Claude Desktop. In hosts that support MCP Apps, a rendered diagram opens in an inline viewer. `strataglyph mcp --port 8765` serves the same tools over HTTP on 127.0.0.1, where specs are passed as text and nothing is read from or written to disk; a request body over 16 MB gets 413, and past 4 waiting calls the next gets 503. Over either transport a spec may be up to 1 MB with at most 2000 nodes and edges, and a result carries at most 8 MB of outputs.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 20 lines
  1. {
  2. "name": "strataglyph",
  3. "owner": {
  4. "name": "Ram Prasad Atluri",
  5. "url": "https://github.com/ATLURI0001"
  6. },
  7. "metadata": {
  8. "description": "Professional architecture and system design diagrams with official cloud icons, rendered to SVG, PNG, draw.io, TSX and HTML."
  9. },
  10. "plugins": [
  11. {
  12. "name": "strataglyph",
  13. "source": "./",
  14. "description": "The strataglyph skill: official AWS, Azure, Google Cloud, Kubernetes, GitHub and IBM icons, ELK auto-layout you can steer, SVG/PNG/draw.io/TSX/HTML output and design documents, an MCP server, planner and author agents, a review board of four reviewer agents and 77 reference diagrams.",
  15. "version": "0.13.0",
  16. "license": "MIT",
  17. "category": "design"
  18. }
  19. ]
  20. }
README.md · README · 253 lines
  1. <div align="center">
  2. <picture>
  3. <source media="(prefers-color-scheme: dark)" srcset="docs/hero-dark.svg">
  4. <source media="(prefers-color-scheme: light)" srcset="docs/hero-light.svg">
  5. <img alt="GitOps delivery drawn by strataglyph: GitHub Actions bumps the manifests repository, Argo CD syncs GKE, AKS and EKS behind Cloudflare, and Grafana queries them, in official icons" src="docs/hero-dark.svg" width="100%">
  6. </picture>
  7. # StrataGlyph
  8. Maintained by [Ram Prasad Atluri](https://github.com/ATLURI0001) · [Portfolio](https://ramprasadatluri.dev)
  9. **Animated architecture and system design diagrams with official AWS, Azure, Google Cloud, Kubernetes, GitHub and IBM icons.**<br>
  10. One YAML spec in; SVG, PNG, editable draw.io, a React component and an HTML viewer out.<br>
  11. **[atluri0001.github.io/strataglyph](https://atluri0001.github.io/strataglyph/)**: every example in light and dark, with its spec and downloads.
  12. [![CI](https://github.com/ATLURI0001/strataglyph/actions/workflows/ci.yml/badge.svg)](https://github.com/ATLURI0001/strataglyph/actions/workflows/ci.yml)
  13. ![Version](https://img.shields.io/badge/version-0.13.0-2563eb)
  14. ![Icons](https://img.shields.io/badge/official_icons-18%2C307-2563eb)
  15. ![License](https://img.shields.io/badge/license-MIT-2563eb)
  16. </div>
  17. The diagram above is [docs/hero.yaml](docs/hero.yaml): 42 lines of YAML, laid out and rendered by strataglyph in its default `stage` skin: the groups light, then the tiles, then a packet with a comet tail runs the main path in order, lighting each line behind it, on a loop. Every picture in this README is the stage skin; `skin: classic` (or `--skin classic`) draws the same layout in each vendor's own diagram style, with a packet along every edge. GitHub keeps the animation; the PNG of the same spec is a still frame.
  18. ## What you get
  19. - **Official, current icons only.** 18,307 icons: AWS (810), Azure (643), Google Cloud (233), Kubernetes (40), GitHub Octicons (408) and IBM Carbon (2,783), plus 5,558 tech logos, 6,305 neutral symbols and Phosphor (1,527) in six weights for system design and business flows; your own SVGs work too, as `local:` icons drawn and checked with `strataglyph icons new` and `icons check`. The cloud packs are rebuilt from each vendor's own download, pinned by checksum. Google Cloud products get the icon Google's 2026 guide assigns them; deprecated sets and unofficial redraws of cloud icons are left out.
  20. - **Official conventions.** AWS groups follow the AWS Architecture Icons deck (borders, dashes, corner tiles, label placement, open arrowheads, numbered callouts); Google Cloud and Azure groups are measured from their own reference diagrams. Every value cites its source in [styles.md](skills/strataglyph/references/styles.md).
  21. - **Business flows too.** `kind:` turns the same spec into an ISO 5807 flowchart, a BPMN 2.0 process with pools, lanes and message flows, a UML state machine, an org chart, a two-sided mind map or a customer journey map with an emotion curve. In the stage skin a process plays as a BPMN token: it splits at parallel gateways, waits at the join and follows the yes branch.
  22. - **Data models, sequences and roadmaps.** `kind: er` draws tables with typed, keyed rows and crow's foot relationships that meet the rows they join, and `strataglyph import sql` starts one from your `CREATE TABLE` statements. `kind: sequence` draws a call flow message by message, with replies dashed, activation bars and loop or alt fragments, played in order. `kind: timeline` draws a roadmap by month, quarter or year: lanes, status-styled bars, milestones, dependency arrows and a today marker.
  23. - **Automatic layout you can steer.** The Eclipse Layout Kernel places nested boundaries, routes edges at right angles, joins fan-in and fan-out into trunks and keeps the order you wrote unless that would cross edges. No coordinates to write; when you want a say, `rank: first`, `align: <node>`, `cols: 2` on a group and `layout: { aspect: 4:3 }` pin a node's place in the flow, line nodes up, grid a group's children and keep a figure compact enough to read in a README.
  24. - **One spec, many figures.** `views:` draws an overview and its details from one source (`render --view all`), so they cannot drift apart; `classes:` share presets, `include:` pulls in a frame every figure shares, and `tags:` color and restyle what they mark, with a legend row each.
  25. - **Diagrams that stay true to the code.** `strataglyph import` starts a spec from Terraform, CloudFormation or CDK output, Docker Compose, Kubernetes manifests or a Mermaid flowchart, sequence, ER, state or gantt diagram, with every node's `evidence:` (the file, line and identifier it came from). `strataglyph verify` fails when a piece of evidence no longer exists, and `--link` makes each node a commit-pinned link to its code. `strataglyph diff` shows what changed between two versions as a colored picture, and the GitHub Action posts it, with the review, on every pull request.
  26. - **Diagrams that move.** Animated SVG by default: packets travel every edge at one speed, the main path plays as a story, line styles stay as drawn. `animate: flow` for marching dashes, `--static` for a still file.
  27. - **Two skins, one layout.** The default `stage` skin draws every diagram as an animated scene, dark by default: a hairline grid with one tint, ink tiles with each icon in a muted share of its own vendor color, mono caps labels, dim wires and one story that plays along them. `skin: classic` (or `--skin classic`) follows each vendor's own diagram style instead, for docs that must match the AWS, Azure or Google Cloud deck. Every position stays the same; dark and light.
  28. - **Eight outputs from one spec.** SVG for READMEs and docs, PNG for slides and chat (3x by default, sharp when zoomed), `.drawio` you can keep editing, `.drawio.svg` (one file that shows as an image anywhere and opens as an editable diagram in draw.io), a TSX component for React sites, a standalone HTML viewer with dark mode, pan and pinch zoom, Mermaid text for wikis that draw only Mermaid, and a sequence diagram of the main path. Every SVG and PNG carries its own spec, so `strataglyph import picture` turns a picture back into an editable diagram. `strataglyph doc` puts the figures into a design document as HTML, Markdown or Word.
  29. - **Made for agents.** A skill with a fast path and authoring rules, a JSON Schema, 482 short aliases (`aws:s3`, `azure:aks`, `k8s:deploy`, and business names such as `generic:invoice` and `generic:approval`), ranked icon search, a validator whose every finding names the subject and the fix, an MCP server for clients without skills, and agents that plan a diagram from your code and check it against it.
  30. - **No install.** The CLI, layout engine, PNG renderer, fonts and the official cloud packs ship in the skill folder (9 MB). Logo and glyph sets are not copied in: they load from their own npm libraries the first time a diagram uses them, verified by checksum and cached. Node.js 22 or newer is all it needs.
  31. ## How it works
  32. <picture>
  33. <source media="(prefers-color-scheme: light)" srcset="docs/how-it-works-light.svg">
  34. <img alt="A YAML spec is validated, laid out by ELK, checked and rendered with the icon packs to SVG, PNG, draw.io, TSX and HTML" src="docs/how-it-works-dark.svg" width="100%">
  35. </picture>
  36. ## Install
  37. From this checkout, run `node skills/strataglyph/scripts/strataglyph.mjs doctor`. Scoped npm commands require a release under `@atluri0001/strataglyph`.
  38. Claude Code plugin:
  39. ```
  40. /plugin marketplace add ATLURI0001/strataglyph
  41. /plugin install strataglyph@strataglyph
  42. ```
  43. Any agent that reads [Agent Skills](https://agentskills.io) (Codex, Cursor, Gemini CLI, Kiro and others):
  44. ```bash
  45. npx skills add ATLURI0001/strataglyph
  46. gh skill install ATLURI0001/strataglyph strataglyph # GitHub CLI, any supported agent
  47. gemini extensions install https://github.com/ATLURI0001/strataglyph # Gemini CLI extension
  48. ```
  49. Only the CLI, from npm:
  50. ```bash
  51. npx @atluri0001/strataglyph doctor
  52. npx @atluri0001/strataglyph render diagram.yaml -f all --theme both
  53. ```
  54. Or from a clone: `node strataglyph/skills/strataglyph/scripts/strataglyph.mjs doctor`.
  55. As an MCP server, for any client that speaks the Model Context Protocol (tools: authoring guide, validate, render, review, icon search, templates, patch candidates, draw.io link):
  56. ```json
  57. { "mcpServers": { "strataglyph": { "command": "npx", "args": ["-y", "@atluri0001/strataglyph", "mcp"] } } }
  58. ```
  59. That block goes in `.mcp.json` for Claude Code, `~/.gemini/settings.json` for Gemini CLI, `.cursor/mcp.json` for Cursor and `.kiro/settings/mcp.json` for Kiro; Codex takes `[mcp_servers.strataglyph]` with `command = "npx"` and `args = ["-y", "@atluri0001/strataglyph", "mcp"]` in `~/.codex/config.toml`. `strataglyph mcp install <client>` writes that entry for you (`claude-code`, `claude-desktop`, `cursor`, `vscode`, `gemini`, `codex` or `kiro`, in the project or with `user` for every project), keeping every other server in the file. Each release publishes the server to the MCP Registry as `io.github.ATLURI0001/strataglyph` and attaches an `.mcpb` bundle for one-click install in Claude Desktop. In hosts that support MCP Apps, a rendered diagram opens in an inline viewer. `strataglyph mcp --port 8765` serves the same tools over HTTP on 127.0.0.1, where specs are passed as text and nothing is read from or written to disk; a request body over 16 MB gets 413, and past 4 waiting calls the next gets 503. Over either transport a spec may be up to 1 MB with at most 2000 nodes and edges, and a result carries at most 8 MB of outputs.
  60. ## Quick start
  61. Ask your agent for a diagram ("draw the architecture of this repo", "a three-tier web app on AWS across two Availability Zones", "turn this Mermaid flowchart into a Google Cloud diagram"). It writes a spec, validates it, renders it and checks the picture. Or write one yourself:
  62. ```yaml
  63. title: Orders API
  64. direction: right
  65. groups:
  66. cloud: { type: aws:cloud }
  67. region: { type: aws:region, label: eu-west-1, in: cloud }
  68. nodes:
  69. users: { icon: aws:users, label: Customers }
  70. api: { icon: aws:api-gateway, in: region }
  71. fn: { icon: aws:lambda, label: Create order, in: region }
  72. table: { icon: aws:dynamodb, label: Orders, in: region }
  73. edges:
  74. - users -> api: HTTPS
  75. - api -> fn -> table
  76. ```
  77. ```bash
  78. node skills/strataglyph/scripts/strataglyph.mjs render orders.yaml -f svg,png
  79. ```
  80. Labels default to the official service names, so `{ icon: aws:lambda }` reads "AWS Lambda". Edges use arrows: `->` solid, `-->` dashed, `..>` dotted, `==>` thick, `<->` both ways, `a -> b, c` to fan out. The full format is in [spec.md](skills/strataglyph/references/spec.md).
  81. ## Examples
  82. [`aws-three-tier`](skills/strataglyph/examples/aws-three-tier.yaml): a VPC across two Availability Zones with public, web and data subnets and an Auto Scaling group drawn across both zones, in the AWS deck's own group styles.
  83. <a href="examples/aws-three-tier.svg"><img src="examples/aws-three-tier.svg" alt="Three-tier web application on AWS across two Availability Zones"></a>
  84. That is one of 77 reference diagrams across AWS (from agents on Bedrock AgentCore to disaster recovery, threat detection, network inspection, migration and contact centers), Azure, Google Cloud, IBM Cloud, Kubernetes, AI and ML, data platforms, CI/CD, C4, system design and business flows (flowcharts, a BPMN process, swimlanes, a state machine, an org chart, a mind map and a customer journey), each rendered from a spec in [skills/strataglyph/examples](skills/strataglyph/examples) and checked against the renderer by CI. Browse them all in light and dark, with each spec and every output to download, at **[atluri0001.github.io/strataglyph/gallery](https://atluri0001.github.io/strataglyph/gallery/)**, or in [examples/README.md](examples/README.md) with the command that renders each one. `strataglyph init <name>` copies any of them as a starting point.
  85. ## Validation that tells you the fix
  86. ```text
  87. $ strataglyph validate orders.yaml
  88. error DG101 node "fn" uses unknown icon "aws:lamda" {"node":"fn","icon":"aws:lamda"}
  89. fix: use icon "aws:lambda"
  90. fix: run `strataglyph icons search lamda`
  91. error DG108 unknown key "lable" in node "db" {"where":"node \"db\"","key":"lable"}
  92. fix: rename "lable" to "label"
  93. failed: 2 error(s), 0 warning(s)
  94. ```
  95. Spec errors (DG1xx) stop the render; composition warnings (DG2xx: an edge through a node, colliding labels, a diagram too wide to read) keep it going unless `--strict` is set. `render --json` writes every file atomically and prints a receipt with the size and SHA-256 of each output.
  96. ## A review board that measures before it judges
  97. `strataglyph review` looks at the diagram at the width readers see it (880 px for a README column) and scores six dimensions: official conventions, layout, grid, arrows and flow, overlap, and size and quality.
  98. ```text
  99. $ git show v0.2.1:skills/strataglyph/examples/gitops-kubernetes.yaml > gitops-0.2.yaml
  100. $ strataglyph review gitops-0.2.yaml --width 880
  101. review gitops-0.2: 1964x786 in a 880px column, seen at 880x352 (scale 0.45, light)
  102. score 85.3/100 FAIL (pass = no blocker or major and score >= 85)
  103. ...
  104. blocker quality.label-size node labels render at 5.82px at this width (1964px canvas shown at 0.45x)
  105. fix: use direction: down so the diagram is narrower
  106. ```
  107. The review loop took that diagram to 98.5 and passing: it now runs top to bottom, so its labels show at full size in the README column.
  108. In Claude Code, `/strataglyph:review <spec>` runs the full loop. Code measures everything that can be counted: overlaps, crossings, alignment, zig-zags and avoidable bends, lines that skim an icon, empty or lopsided groups, text size and contrast at display width. Read-only agents run in parallel and judge what cannot be counted:
  109. - `conventions-reviewer` checks the vendor's own rules, quoted from the AWS deck, Azure Well-Architected, Google's icon guide and the C4 notation.
  110. - `flow-reviewer` checks the story the arrows tell.
  111. - `legibility-reviewer` reads the PNG at display size.
  112. - `accuracy-reviewer` checks the diagram against the code and infrastructure it shows, when there is any.
  113. A finding counts only if it cites a measured value, a vendor rule or a source line. Each round, `patch-proposer` agents write two to four candidate patch sets and `strataglyph patch` tries them all at once; a round is kept only when the best candidate raises the score and no hard count goes up; the loop stops after three rounds or two without progress. Vision models are weak at counting overlaps and intersections, so they never decide those. The rubrics live in [references/review](skills/strataglyph/references/review/loop.md), so the same passes run inline anywhere the skill is installed without subagents.
  114. ## Agents that draw from your code
  115. In Claude Code, `/strataglyph:draw <what to draw>` starts from the request and the system itself. The `kind-router` agent decides which kind each figure is (architecture, flowchart, BPMN process, state machine, tree, mind map, customer journey, data model, sequence or timeline), the closest template and up to three framings, and lists anything no kind can draw with a workaround. When there is code or infrastructure, the `planner` agent reads the infrastructure and code (Terraform, CloudFormation, SAM, CDK output, Kubernetes, Compose, the handlers) and returns every service, boundary and flow with the file and line it came from, marking which flows the infrastructure declares and which the code only implies, plus what it leaves out and why. You confirm that list before any spec exists. `diagram-author` agents then write the specs; a figure of more than 8 nodes is drafted three times (never more than four), one framing each, and the draft with the fewest overlaps, crossings and edges through nodes, then the best score, is kept by measurement alone. Then the spec is validated and run through the review board, where a fourth reviewer, `accuracy-reviewer`, checks the drawing against the sources on its own: invented nodes, dependencies drawn as traffic, arrows pointing the wrong way, services in the wrong subnet. It never sees the planner's reasoning, so it cannot inherit its mistakes.
  116. `/strataglyph:doc <topic>` writes a design document: the planner picks one figure per aspect (overview, request path, data, deployment, failure handling), `diagram-author` agents draw them in parallel, each is reviewed, and `strataglyph doc` builds the Markdown into HTML or Word with numbered figures.
  117. Fixes are measured, not argued: `patch-proposer` agents write candidate patch sets under different strategies (fewer arrows, a different structure, better words, the vendor's rules), and `strataglyph patch` reviews each candidate on its own copy and keeps only the one that scores best without making anything worse. A plugin hook validates every spec the moment an agent writes it, so errors come back with their fixes before anything renders, and a SubagentStop gate sends `diagram-author` and `image-importer` back to work, at most twice, until their spec passes `validate --strict` (and, for `diagram-author`, the measured review). The planning and accuracy rules live in [planning.md](skills/strataglyph/references/planning.md) and [accuracy.md](skills/strataglyph/references/review/accuracy.md), so clients without subagents run the same passes in order.
  118. ## In pull requests
  119. The repository is also a GitHub Action. It validates, renders and reviews every spec, draws what changed in the specs a pull request touches, and keeps one comment on the pull request with the scores and a link to the pictures:
  120. ```yaml
  121. on: pull_request
  122. permissions:
  123. contents: read
  124. pull-requests: write
  125. jobs:
  126. diagrams:
  127. runs-on: ubuntu-latest
  128. steps:
  129. - uses: actions/checkout@v6
  130. - uses: ATLURI0001/strataglyph@v0.13.0
  131. with:
  132. specs: docs/**/*.yaml # git pathspec globs, one per line
  133. fail-on: error # or warning, or review (fail when the review does not pass)
  134. ```
  135. ## Editors and the browser
  136. `strataglyph lsp` is a language server for spec files: findings on the characters they are about, their fixes as quick fixes, and completion for icon ids, group types and ids. [editors/vscode](editors/vscode/README.md) is a thin VS Code client for it, and any editor that speaks the Language Server Protocol can use the same server. The [playground](https://atluri0001.github.io/strataglyph/play/) runs the CLI's own parser, layout, renderers and review in the browser: edit a spec, watch it redraw, download every format, or share a link that carries the spec.
  137. ## Commands
  138. | Command | Does |
  139. | --- | --- |
  140. | `render <spec> [-o base] [-f svg,png,drawio,drawio.svg,tsx,html,mmd,sequence.svg\|all] [--theme light\|dark\|both] [--skin classic\|stage] [--animate packets\|flow\|relay\|none] [--static] [--view <name>\|all]` | Validate, lay out, render; `--view` draws one of the spec's views, or every view as its own file. |
  141. | `watch <spec> [-o base] [-f svg,png] [--review]` | Render again on every save of the spec, its local icons or its includes, and print the review score each time with `--review`. One spec per watch. |
  142. | `validate <spec...> [--strict] [--json]` | Spec errors and composition warnings, each with fixes; `render` and `validate` take several specs at once (with `-o` a folder). |
  143. | `review <spec> [--width 880] [--theme light\|dark] [--view <name>\|all] [--strict] [--json]` | Score the diagram (or its views) at the width readers see it, at least 200 px; writes `<base>.review.json` and a PNG at that width (plus `<base>.review.look.png`, scaled to fit 1568 px, when that PNG is larger). |
  144. | `patch <spec> <candidates.json> [-o best.yaml] [--width 880]` | Try several candidate patch sets at once, each reviewed on its own copy; keeps the best one that improves the score, with comments and formatting untouched. |
  145. | `doc <design.md> [-f html,md,docx]` | Build a design document: each `<!-- strataglyph: spec.yaml \| Caption -->` line, or ` ```strataglyph ` fence holding a spec, becomes a numbered figure (inline SVG in HTML, image files next to Markdown, a picture in Word). |
  146. | `mcp [--port 8765]` | Serve the commands as Model Context Protocol tools over stdio, or HTTP on 127.0.0.1. |
  147. | `mcp install <client> [project\|user] [--force]`, `mcp install --list` | Write the strataglyph server entry into a client's MCP config, keeping the rest of the file. |
  148. | `diff <before> <after> [-o changes.svg] [--scale 2] [--json]` | What changed between two specs (`git:<ref>:<path>` reads one from git; a ref may not start with `-`): added, removed, renamed and changed nodes, groups and edges, as text, JSON or the new diagram with the changes colored. |
  149. | `verify <spec> [--link] [--commit <sha>] [--json]` | Check that every `evidence:` still points at a real file, line and identifier inside the repository; `--link` sets each node's `url` to a commit-pinned permalink and lists the nodes it skipped (a file not in the commit or changed since, a node from an include). |
  150. | `describe <spec> [--json]` | A plain-text account of the laid-out diagram: groups, nodes, where they sit and what connects to what. |
  151. | `lsp` | The language server for editors, over stdio. |
  152. | `icons search <words> [--pack aws]` | Ranked icon ids with official names. |
  153. | `icons show <id>`, `icons list`, `icons packs` | Browse the catalog and its sources. |
  154. | `icons fetch` | Download and cache the logo and glyph libraries for offline renders. |
  155. | `icons new <name>`, `icons check <file.svg>`, `icons adopt <file.svg> --name <name>` | Draw your own icon on the 24 grid, check it against the drawing rules with a contact sheet in both skins and themes, or bring in someone's SVG as a clean `local:` icon. |
  156. | `styles` | Every group type and node shape. |
  157. | `init [template]` | Start from one of the examples. |
  158. | `import <mermaid\|terraform\|cloudformation\|cdk\|compose\|kubernetes\|sql\|picture> <file> [-o diagram.yaml]` | Start a spec from a Mermaid flowchart, sequence, ER, state or gantt diagram, Terraform, a CloudFormation or CDK template, a Compose file, Kubernetes manifests or a SQL schema (each node with its `evidence:`), or read the spec back out of an SVG or PNG strataglyph drew. |
  159. | `doctor`, `demo` | Check the install; render every example. |
  160. ## Icon packs
  161. | Pack | Icons | Source | Ships |
  162. | --- | ---: | --- | --- |
  163. | `aws` | 810 | [AWS Architecture Icons](https://aws.amazon.com/architecture/icons/), 2026-07-31 package | bundled |
  164. | `azure` | 643 | [Azure Architecture Icons](https://learn.microsoft.com/en-us/azure/architecture/icons/) V25 | bundled |
  165. | `gcp` | 233 | [Google Cloud icons](https://cloud.google.com/icons), core and category icons mapped to products as in Google's May 2026 guide | bundled |
  166. | `k8s` | 40 | [Kubernetes community icons](https://github.com/kubernetes/community/tree/master/icons) | bundled |
  167. | `github` | 408 | [GitHub Octicons](https://primer.style/octicons) | npm `@primer/octicons` |
  168. | `ibm` | 2,783 | [IBM Carbon icons](https://carbondesignsystem.com/elements/icons/library/), IBM's diagram node icons and product glyphs | npm `@iconify-json/carbon` |
  169. | `logos` | 2,206 | [SVG Logos](https://github.com/gilbarbara/logos) | npm `@iconify-json/logos` |
  170. | `si` | 3,352 | [Simple Icons](https://simpleicons.org) | npm `@iconify-json/simple-icons` |
  171. | `tabler` | 6,305 | [Tabler Icons](https://tabler.io/icons) | npm `@iconify-json/tabler` |
  172. | `ph` | 1,527 | [Phosphor Icons](https://phosphoricons.com), six weights by suffix (`ph:handshake-duotone`) | npm `@iconify-json/ph` |
  173. Bundled packs exist only as vendor downloads, so they ship with the skill and work offline. The npm sets load at render time from a local `node_modules`, the user cache or jsDelivr, checked against a pinned SHA-256; `strataglyph icons fetch` caches them ahead of time, and [icons.md](skills/strataglyph/references/icons.md#where-icons-load-from) has the details. Renovate's monthly dependency PR also checks the vendors' pages for new releases and carries the updated packs. Icons, logos and trademarks belong to their owners and are used under the terms listed in [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md); the AWS, Microsoft and Google terms allow them in architecture diagrams.
  174. ## Community
  175. Made a diagram with strataglyph? Share it in [Show and tell](https://github.com/ATLURI0001/strataglyph/discussions/categories/show-and-tell). Questions go to [Q&A](https://github.com/ATLURI0001/strataglyph/discussions/categories/q-a), and requests for icons, examples, outputs or styles to [Ideas](https://github.com/ATLURI0001/strataglyph/discussions/categories/ideas). Found a bug? Open an [issue](https://github.com/ATLURI0001/strataglyph/issues). If strataglyph saved you a diagram, a star helps other people find it.
  176. ## Development
  177. ```bash
  178. pnpm install
  179. pnpm lint
  180. pnpm typecheck
  181. pnpm test
  182. pnpm build # src/ -> skills/strataglyph/scripts/strataglyph.mjs
  183. pnpm gallery # re-render examples/ and docs/
  184. node scripts/check-repo.mjs # dashes, links, counts, doc snippets, gallery freshness
  185. pnpm sync-icons # rebuild icon catalogs (--latest re-pins new vendor releases)
  186. node scripts/pack-npm.mjs # stage the npm package in out/npm (a GitHub release publishes it)
  187. ```
  188. See [CONTRIBUTING.md](CONTRIBUTING.md) for how the pieces fit and [SECURITY.md](SECURITY.md) for reporting issues.
  189. ## License
  190. Code and docs: [MIT](LICENSE). Icons, fonts and the vendored engines keep their own licenses: [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.