okf 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1f08bf7a4a1a49ef0bea5953b380df85bdbe79e1b30998e0d168d122d4a20c2
-  data.tar.gz: 97aff0312275def9b514c0e50bcc3872a73e3a304efa7ac8d85046a846711a7f
+  metadata.gz: 464529d862280b3385f00fa36a309c81fa03f71db2d2534f11707a04fdca4679
+  data.tar.gz: 1487c71ef1e70340d0a6212b85f0202ae287c0a1df7b59489f643bdbf63dd05f
 SHA512:
-  metadata.gz: '09c1784bee88f5a74087345fa3ee26a13ba2875ff9447559852c23cf294f6f05ffa457eabdd67cbbac4bc5e255b3cc91f128863fab92d9b5a88f3ae41062e871'
-  data.tar.gz: d26885ca8683d2de6ad036d7a158089ba4b7e12437131b617687bad51bd15157f64dd148bcd7f8f502a95ae48d644f9c5674464e82ff3f97bc34faf61a24dc24
+  metadata.gz: 6240c78b9b1c23b64c97f980db2aabe5d3126eb0c69e4eb853381bed2e5e1be991a4835c62a806cfb5e219fdb4b3bf4bf3ef8960063d6f30d5fcf2aaf630d8d2
+  data.tar.gz: 32d943f353984a9d6e7224c881169bf851008976adee4ef6e785878372f225162f4359021b2ab576cf0615dde0b23054b61826ee39b8937356e1759d0dbca0c4

data/.okf/capabilities/graph-server.md

@@ -4,14 +4,15 @@ title: Interactive graph server (server)
 description: A self-contained HTML knowledge graph served over HTTP, and a mountable Rack app.
 resource: lib/okf/server/app.rb
 tags: [server, graph, rack, diagram]
-timestamp: 2026-07-11T12:00:00Z
+timestamp: 2026-07-12T12:00:00Z
 ---
 
 # Overview
 
 `okf server` boots an interactive view of the [graph](../model/graph.md):
 `OKF::Server::App` is a Rack app that serves one self-contained HTML page which
-draws the bundle with Cytoscape and renders concept bodies with marked. Because
+draws the bundle with Cytoscape and renders concept bodies with marked, sanitized
+by DOMPurify. Because
 it is a plain Rack app, it also mounts inside a host application (e.g. a Rails
 route) — the built-in WEBrick runner is just the default, injected so tests drive
 it without opening a socket.
@@ -19,8 +20,9 @@ it without opening a socket.
 # The page stays self-contained
 
 One ERB template, inline CSS and JS, no build step and no bundler. The only
-external assets are Cytoscape and marked from a CDN — plus Mermaid, lazy-loaded
-only when a concept body actually contains a diagram; everything else is inlined.
+external assets are Cytoscape, marked, and DOMPurify from a CDN — plus Mermaid,
+lazy-loaded only when a concept body actually contains a diagram; everything else
+is inlined.
 The graph draws from a **minimal** node payload and pulls each concept's body
 **on demand** via `fetch()`, which is why even a large bundle loads fast.
 
@@ -35,7 +37,7 @@ sequenceDiagram
   Note over A,B: angle brackets escaped (json_for_script) — safe
   B->>A: GET /node?id=… (on demand)
   A-->>B: concept Markdown body
-  Note over A,B: marked renders it UNSANITIZED — trust boundary
+  Note over A,B: marked renders it, DOMPurify sanitizes it — safe
 ```
 
 # Endpoints
@@ -49,11 +51,12 @@ sequenceDiagram
 
 # Trust boundary
 
-Fetched Markdown bodies are rendered **without sanitization**, so only serve
-bundles you trust. Data inlined into the page is safe — it goes through
-`json_for_script`, which escapes `<` so it cannot break out of its `<script>` —
-but the on-demand body is not. See the
-[server trust boundary](../design/server-trust-boundary.md) for the full picture.
+Both paths into the page are guarded. Inlined data goes through `json_for_script`,
+which escapes `<` so it cannot break out of its `<script>`; each fetched body is
+run through `DOMPurify.sanitize(marked.parse(...))`, which strips any script or
+handler before it reaches the DOM. See the
+[server trust boundary](../design/server-trust-boundary.md) for what that does and
+does not cover.
 
 # Citations
 

data/.okf/capabilities/library-api.md

@@ -4,7 +4,7 @@ title: Library API
 description: The Ruby surface — a pure in-memory model plus on-disk handles, an "ActiveRecord for the filesystem".
 resource: lib/okf.rb
 tags: [library, api, ruby, diagram]
-timestamp: 2026-07-11T12:00:00Z
+timestamp: 2026-07-12T12:00:00Z
 ---
 
 # Overview
@@ -18,6 +18,11 @@ gives you two layers, split cleanly by the [core/shell rule](../design/core-shel
 - **on-disk handles** — `OKF::Concept::File` and `OKF::Bundle::Folder`, which add
   `load` / `save` / `reload` / `delete` on top of the pure model.
 
+`require "okf"` stops at those two layers: the [CLI](../cli.md) and the skill
+installer load only when asked for (from `exe/okf`, or an explicit
+`require "okf/cli"` / `require "okf/skill"`), so an app embedding the library
+never drags in the command-line machinery.
+
 ```mermaid
 classDiagram
   class Concept {

data/.okf/design/index.md

@@ -7,4 +7,4 @@ the code looks the way it does.
 * [Core/shell split](core-shell-split.md) - pure logic must never touch disk, stdio, or the shell layer; a test enforces it.
 * [Ruby 2.4 floor](ruby-floor.md) - runs on the Ruby an OS already ships; newer APIs are banned.
 * [Runtime dependencies](runtime-dependencies.md) - exactly `rack` and `webrick`, no ActiveSupport.
-* [Server trust boundary](server-trust-boundary.md) - the served page renders concept bodies unsanitized.
+* [Server trust boundary](server-trust-boundary.md) - the served page sanitizes concept bodies and escapes inlined data; both XSS paths are closed.

data/.okf/design/server-trust-boundary.md

@@ -1,35 +1,40 @@
 ---
 type: Constraint
 title: The server trust boundary
-description: The served page renders concept bodies without sanitization, so only serve bundles you trust.
+description: The served page sanitizes each concept body before rendering and escapes inlined data, so both XSS paths into the page are closed.
 resource: lib/okf/server/templates/graph.html.erb
 tags: [security, server, xss]
-timestamp: 2026-07-11T12:00:00Z
+timestamp: 2026-07-12T12:00:00Z
 ---
 
 # Overview
 
-The [graph server](../capabilities/graph-server.md) is designed for trusted
-bundles. Its page renders each concept's Markdown body **without sanitization**
-(marked, no sanitizer), so a hostile bundle could carry active content. The rule
-is simple: **only serve bundles you trust.**
+The [graph server](../capabilities/graph-server.md) renders whatever bundle you
+point it at, and a bundle is just files, so the page has to assume a body might
+carry active content. Two defenses handle that — one for each path into the page.
 
 # Where the boundary sits
 
-There are two different data paths into the page, and only one is escaped:
+There are two data paths into the page, and each carries its own guard:
 
 | Path | Handling | Safe? |
 |------|----------|-------|
 | Graph data **inlined** into the page | through `json_for_script`, which escapes `<` | yes — it cannot break out of its `<script>` |
-| Concept bodies **fetched** on demand (`/node?id=`) | rendered as Markdown, unsanitized | no — this is the trust boundary |
+| Concept bodies **fetched** on demand (`/node?id=`) | `marked` renders the Markdown, then `DOMPurify.sanitize` scrubs it before it reaches the DOM | yes — scripts, handlers, and `javascript:` URLs are stripped |
 
-So the XSS boundary is not the inlined data (that is handled); it is the
-on-demand [body](../format/cross-links.md) render. The
-[self-contained page](../capabilities/graph-server.md) keeps external assets down
-to Cytoscape and marked from a CDN, but that does not make the rendered body
-safe.
+The [description](../format/cross-links.md) shown in the inspector takes a third
+path and never needs the client's help: the server escapes it
+(`OKF::Server::App#description_fragment`) before sending it, so it arrives inert.
+
+# What sanitizing does not cover
+
+DOMPurify removes the code, not the content. The page still fetches and shows the
+links, images, and Mermaid diagrams a body names (Mermaid runs in its `strict`
+mode), and it pulls Cytoscape, marked, and DOMPurify from a CDN. So the rule is no
+longer *only serve bundles you trust* — it is the ordinary care you would give any
+document from a source you do not know.
 
 # Citations
 
-[1] [README.md — Server trust boundary](https://github.com/serradura/okf-gem/blob/main/README.md) — the unsanitized-render warning.
-[2] [lib/okf/server/templates/graph.html.erb](https://github.com/serradura/okf-gem/blob/main/lib/okf/server/templates/graph.html.erb) — `json_for_script` and the body render.
+[1] [README.md — Server trust boundary](https://github.com/serradura/okf-gem/blob/main/README.md) — the two-defense summary.
+[2] [lib/okf/server/templates/graph.html.erb](https://github.com/serradura/okf-gem/blob/main/lib/okf/server/templates/graph.html.erb) — `json_for_script` and the `DOMPurify.sanitize(marked.parse(...))` render.

data/.okf/log.md

@@ -1,6 +1,7 @@
 # Update Log
 
 ## 2026-07-12
+* **Sync**: caught the bundle up with the gem at 1.1.0 — the [graph server](capabilities/graph-server.md) now sanitizes each fetched body with DOMPurify before rendering, so the [server trust boundary](design/server-trust-boundary.md) closes the on-demand render path (its [design listing](design/) reworded to match), and the [library API](capabilities/library-api.md) notes that `require "okf"` loads the library alone now that the CLI and skill load on demand.
 * **Sync**: caught the bundle up with the CLI at 1.0.0 — documented the new `index` command (the §6 progressive-disclosure map, the read view that sees the reserved `index.md` layer), compact-by-default JSON with `--pretty`, and `--fields`/`--except` projection on the list views, in [read views](capabilities/read-views.md) plus the `index`-verb enumerations in the [CLI](cli.md), the [overview](overview.md), and the [capabilities](capabilities/) index listing.
 
 ## 2026-07-11

data/.okf/overview.md

@@ -15,8 +15,9 @@ gives you leverage over knowledge that already lives as Markdown.
 
 ```mermaid
 flowchart LR
-  skill["companion<br/>agent skill"] -. authors .-> bundle[("OKF v0.1 bundle<br/>Markdown + YAML")]
+  skill["companion<br/>agent skill"] -. authors/curate .-> bundle[("OKF v0.1 bundle<br/>Markdown + YAML")]
   bundle --> model["pure model<br/>Concept · Bundle · Graph"]
+  skill -. execute .-> cli
   subgraph cli ["okf CLI"]
     validate["validate — legal? §9"]
     lint["lint — well-curated?"]
@@ -29,13 +30,13 @@ flowchart LR
 Over such a bundle the gem gives you five capabilities behind one
 [command-line tool](cli.md):
 
-| Capability | What it answers | Verb |
-|------------|-----------------|------|
-| [Conformance validator](capabilities/validator.md) | Is this a legal OKF bundle? (§9) | `validate` |
-| [Curation linter](capabilities/linter.md) | Is it navigable, complete, fresh? | `lint` / `loose` |
-| [Interactive graph server](capabilities/graph-server.md) | Can I explore it visually? | `server` |
-| [Library API](capabilities/library-api.md) | Can my Ruby program use it? | (in-process) |
-| [Companion agent skill](capabilities/agent-skill.md) | Can an agent author it? | `skill` |
+| Capability                                               | What it answers                   | Verb             |
+| -------------------------------------------------------- | --------------------------------- | ---------------- |
+| [Companion agent skill](capabilities/agent-skill.md)     | Can an agent author it?           | `skill`          |
+| [Conformance validator](capabilities/validator.md)       | Is this a legal OKF bundle? (§9)  | `validate`       |
+| [Curation linter](capabilities/linter.md)                | Is it navigable, complete, fresh? | `lint` / `loose` |
+| [Interactive graph server](capabilities/graph-server.md) | Can I explore it visually?        | `server`         |
+| [Library API](capabilities/library-api.md)               | Can my Ruby program use it?       | (in-process)     |
 
 Alongside those, a family of [read views](capabilities/read-views.md) —
 `index`, `catalog`, `files`, `tags`, `stats`, `graph` — print the bundle at a
@@ -43,7 +44,7 @@ glance so an agent reads it without a browser.
 
 # The two ideas it inherits from the format
 
-- **Dual audience.** Every file serves a human skimming it *and* an agent
+- **Dual audience.** Every file serves a human skimming it _and_ an agent
   extracting from it, so bodies are structural Markdown and
   [links](format/cross-links.md) are plain Markdown links — both readers already
   understand them.

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [1.1.0] - 2026-07-12
+
+- The graph server now sanitizes every concept body before rendering it. The
+  page runs marked's HTML output through [DOMPurify](https://github.com/cure53/DOMPurify)
+  (loaded from the same CDN as Cytoscape and marked) on the way to the DOM, so a
+  bundle carrying active content in a Markdown body can no longer script the
+  viewer. Inlined graph data was already escaped through `json_for_script`; this
+  closes the other path.
+- `require "okf"` now loads the pure library only. The two argv-facing shells —
+  `OKF::CLI` and the `OKF::Skill` installer — load on demand, from `exe/okf` or
+  an explicit `require "okf/cli"` / `require "okf/skill"`. `optparse` moves with
+  the CLI, so an embedding app (e.g. a Rails store) that only reaches for the
+  in-memory model and on-disk handles no longer pulls in the command-line
+  machinery. The CLI itself is unchanged.
+
 ## [1.0.0] - 2026-07-12
 
 Initial release.

data/README.md

@@ -5,17 +5,59 @@
 </h1>
 </p>
 
-> A rough project, cut and polished into a jewel. And like any jewel, what it is
-> worth comes down to what it does with knowledge: reading it, validating it,
-> curating it, and putting it on display.
-
-**okf-gem** reads, validates, lints, and serves **Open Knowledge Format (OKF)**
-v0.1 bundles. OKF is portable knowledge: a directory of Markdown files with YAML
-frontmatter that both humans and agents read. Each file is a _concept_; a
-directory of them is a _bundle_. Over such a bundle the gem gives you five
-things: a library API, a conformance validator, a curation linter, an
-interactive graph server, and a companion agent skill. All but the library API
-are reachable through one `okf` command-line tool.
+<p align="center">
+  <i>A lightweight Ruby gem for OKF: author, curate, and serve bundles as an interactive graph.</i>
+</p>
+
+<p align="center">
+  <a href="https://rubygems.org/gems/okf"><img src="https://img.shields.io/gem/v/okf" alt="Gem version"></a>
+  <a href="https://rubygems.org/gems/okf"><img src="https://img.shields.io/gem/dt/okf" alt="Downloads"></a>
+  <a href="https://github.com/serradura/okf-gem/actions/workflows/main.yml"><img src="https://github.com/serradura/okf-gem/actions/workflows/main.yml/badge.svg" alt="CI"></a>
+  <a href="https://github.com/serradura/okf-gem"><img src="https://img.shields.io/badge/ruby-%3E%3D%202.4-black" alt="Ruby >= 2.4"></a>
+  <a href="LICENSE.txt"><img src="https://img.shields.io/badge/license-Apache--2.0-blue" alt="License: Apache-2.0"></a>
+  <a href="lib/okf/skill/reference/SPEC.md"><img src="https://img.shields.io/badge/OKF-v0.1-6E56CF" alt="OKF v0.1"></a>
+</p>
+
+**okf-gem** — `okf` on RubyGems — reads, validates, lints, and serves
+**Open Knowledge Format (OKF)** v0.1 bundles: directories of Markdown files with YAML frontmatter that humans and agents read from one source. It does not define a new place to keep knowledge; it gives you leverage over knowledge that already lives as Markdown. Each file is a _concept_; a directory of them is a _bundle_.
+
+Here is what it is able to do:
+
+```mermaid
+flowchart LR
+  skill["companion<br/>agent skill"] -. authors/curate .-> bundle[("OKF v0.1 bundle<br/>Markdown + YAML")]
+  bundle --> model["pure model<br/>Concept · Bundle · Graph"]
+  skill -. execute .-> cli
+  subgraph cli ["okf CLI"]
+    validate["validate — legal? §9"]
+    lint["lint — well-curated?"]
+    server["server — explore"]
+  end
+  model --> cli
+  model --> library["library API<br/>embed in Ruby"]
+```
+
+Over a bundle the gem gives you the `okf`
+command-line tool (the library API is also usable in-process). Each capability
+below links to the concept that documents it: this gem's own knowledge is an OKF
+bundle, so you can read its design in the format it defends.
+
+| Capability                                                    | What it answers                   | Verb             |
+| ------------------------------------------------------------- | --------------------------------- | ---------------- |
+| [Companion agent skill](.okf/capabilities/agent-skill.md)     | Can an agent author it?           | `skill`          |
+| [Conformance validator](.okf/capabilities/validator.md)       | Is this a legal OKF bundle? (§9)  | `validate`       |
+| [Curation linter](.okf/capabilities/linter.md)                | Is it navigable, complete, fresh? | `lint` / `loose` |
+| [Interactive graph server](.okf/capabilities/graph-server.md) | Can I explore it visually?        | `server`         |
+| [Library API](.okf/capabilities/library-api.md)               | Can my Ruby program use it?       | in-process       |
+
+> [!TIP]
+> **Browse the gem as knowledge, not just docs.** This README is the front door;
+> the depth lives in the [`.okf/`](.okf) bundle this repo ships. Start at the
+> [overview](.okf/overview.md), then follow the graph into the
+> [capabilities](.okf/capabilities/) (what it does), the
+> [design constraints](.okf/design/) (why it stays this light), and the
+> [format itself](.okf/format/) (what it operates on). Run `okf server .okf` to
+> walk the same bundle as an interactive graph.
 
 It is deliberately light so it runs on the Ruby your OS already ships:
 
@@ -23,7 +65,57 @@ It is deliberately light so it runs on the Ruby your OS already ships:
   its core dependency;
 - only two runtime dependencies: `rack` (the server is a mountable Rack app)
   and `webrick` (unbundled from Ruby in 3.0);
-- no ActiveSupport, no build step, no JavaScript toolchain.
+- no ActiveSupport, no build step, no JavaScript toolchain — the
+  [design constraints](.okf/design/) that hold this line are enforced by tests.
+
+## Why OKF
+
+Project knowledge (why a service exists, what a metric really measures, the
+reasoning a schema encodes) lives scattered across wikis, code comments, and
+whoever happened to be in the room, and an agent re-derives it every session. OKF
+gives it one durable, diffable home, versioned next to the code it describes and
+read from the same file by people and agents alike. [OKF][okf] is an open,
+vendor-neutral format (Google Cloud, 2026); this gem is the Ruby-native way to
+work with it.
+
+[okf]: https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing
+
+## What a bundle looks like
+
+A bundle is just a directory; each concept is one Markdown file whose path is its
+id. This repo documents _itself_ in OKF, so the tree below is real:
+
+```
+.okf/
+├── index.md                       # progressive-disclosure map (root carries okf_version)
+├── log.md                         # ISO-dated change history, newest first
+├── overview.md
+├── format/frontmatter.md
+├── model/graph.md
+└── capabilities/graph-server.md   # one concept = one file
+```
+
+The only hard requirement is YAML frontmatter with a non-empty `type`; everything
+else is optional and tolerated when missing. A concept (here the real
+`capabilities/graph-server.md`, body trimmed) reads:
+
+```markdown
+---
+type: Capability
+title: Interactive graph server (server)
+description: A self-contained HTML knowledge graph served over HTTP, and a mountable Rack app.
+resource: lib/okf/server/app.rb
+tags: [server, graph, rack, diagram]
+timestamp: 2026-07-11T12:00:00Z
+---
+
+# Overview
+
+`okf server` boots an interactive view of the [graph](../model/graph.md) …
+```
+
+That bundle is this gem's own documentation. Clone the repo and run
+`okf server .okf` to browse it as the graph diagrammed at the top of this file.
 
 ## Installation
 
@@ -56,10 +148,6 @@ okf --version
 Exit codes: `0` success, `1` non-conformant bundle (or a `lint --fail-on`
 threshold crossed), `2` usage error.
 
-> [!NOTE]
-> Section numbers like §5, §8, and §9 refer to the OKF v0.1 spec, bundled with
-> the skill at [`lib/okf/skill/reference/SPEC.md`](lib/okf/skill/reference/SPEC.md).
-
 ```bash
 $ okf validate docs
 OKF v0.1 conformance — docs
@@ -82,11 +170,13 @@ _The graph server on this repo's own [`.okf`](.okf) bundle, with the
 
 `graph` and `server` are best-effort (§9): a file with invalid frontmatter is
 skipped (and noted on stderr), not fatal, so one bad file never breaks the rest.
-Before serving a bundle you did not author, read the
-[server trust boundary](#server-trust-boundary).
+The [graph server](.okf/capabilities/graph-server.md) concept walks the request
+flow and endpoints; the [server trust boundary](#server-trust-boundary) below
+explains how the page handles a bundle you did not author.
 
-`lint` reports curation quality (reachability, backlog, completeness, freshness,
-provenance, and hygiene) separately from `validate`. It is advisory: it exits
+`lint` (the [curation linter](.okf/capabilities/linter.md)) reports curation
+quality (reachability, backlog, completeness, freshness, provenance, and hygiene)
+separately from `validate`. It is advisory: it exits
 `0` even with findings unless you opt into gating with `--fail-on warn`.
 
 ```bash
@@ -116,7 +206,8 @@ always exits `0`.
 
 ## Agent skill
 
-The gem carries the companion OKF agent skill: a `SKILL.md` plus reference
+The gem carries the [companion OKF agent skill](.okf/capabilities/agent-skill.md):
+a `SKILL.md` plus reference
 and template files that teach a coding agent to author, maintain, and consume OKF
 bundles and to drive the commands above. Because the skill ships inside the gem,
 installing the gem already puts the skill on your machine, and the skill's
@@ -139,7 +230,8 @@ is never clobbered.
 
 ## Library
 
-The gem is two layers: pure in-memory data (`OKF::Concept`, `OKF::Bundle`)
+The gem (the [library API](.okf/capabilities/library-api.md)) is two layers: pure
+in-memory data (`OKF::Concept`, `OKF::Bundle`)
 you build, interrogate, and analyze with no disk involved, and on-disk
 handles (`OKF::Concept::File`, `OKF::Bundle::Folder`) that add
 load/save/reload/delete, an "ActiveRecord for the filesystem".
@@ -199,7 +291,8 @@ The lower-level pieces are usable on their own too: `OKF::Bundle::Validator.call
 
 ### Conformance model
 
-`validate` implements the spec's [§9 conformance definition](lib/okf/skill/reference/SPEC.md#9-conformance)
+`validate` (the [conformance validator](.okf/capabilities/validator.md)) implements
+the spec's [§9 conformance definition](lib/okf/skill/reference/SPEC.md#9-conformance)
 exactly. There are three hard conditions, all errors:
 
 - **§9.1** every non-reserved file has a parseable YAML frontmatter block;
@@ -236,12 +329,23 @@ is the structured input an agent consumes to reason about those.
 
 ## Server trust boundary
 
-> [!WARNING]
-> The served page loads its JavaScript (Cytoscape, marked, mermaid, and layout
-> plugins) from a CDN and renders each concept's Markdown body **without
-> sanitization**, so only serve bundles you trust. Inlined graph data still
-> cannot break out of its `<script>` (`<` is escaped), but the fetched Markdown
-> is rendered unsanitized.
+> [!NOTE]
+> The graph page defends against a bundle that carries active content in two
+> places. It escapes any graph data inlined into the page (`<` becomes `&lt;`),
+> which keeps that data from breaking out of its `<script>`. And it fetches each
+> concept body on demand, then runs marked's HTML output through
+> [DOMPurify](https://github.com/cure53/DOMPurify) before it reaches the DOM, so
+> a script or event handler hidden in a Markdown body is stripped rather than
+> executed. Descriptions are escaped on the server.
+>
+> That covers the paths that could run code. The page still loads Cytoscape,
+> marked, and DOMPurify from a CDN and renders whatever links and diagrams a body
+> contains, so treat an unfamiliar bundle the way you would treat any document
+> from a source you do not know.
+
+The [server trust boundary](.okf/design/server-trust-boundary.md) concept has the
+full write-up: the two data paths, what sanitizing does, and what it leaves to
+your judgment.
 
 ## Development
 

data/exe/okf

@@ -2,5 +2,7 @@
 # frozen_string_literal: true
 
 require "okf"
+require "okf/skill"
+require "okf/cli"
 
 exit OKF::CLI.start(ARGV)

data/lib/okf/cli.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "optparse"
+
 module OKF
   # Command-line front end: `okf graph|validate|lint|loose|index|catalog|files|tags|types|stats|server <dir>`.
   # This is the

data/lib/okf/server/templates/graph.html.erb

@@ -11,6 +11,7 @@
 <link href="https://fonts.googleapis.com/css2?family=Poppins:wght@400;500;600;700&display=swap" rel="stylesheet">
 <script src="https://cdn.jsdelivr.net/npm/cytoscape@3.30.2/dist/cytoscape.min.js"></script>
 <script src="https://cdn.jsdelivr.net/npm/marked@14/marked.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/dompurify@3/dist/purify.min.js"></script>
 <style>
  :root{
   --bg:#ffffff; --panel:#ffffff; --panel-2:#f6f7f8; --canvas:#f4f5f7; --ink:#1f2328; --ink-soft:#333333;
@@ -466,7 +467,7 @@ function rethemeMermaid(){if(!window.mermaid)return;const nodes=[...document.que
  window.mermaid.initialize({startOnLoad:false,securityLevel:'strict',theme:isDark()?'dark':'default'});
  nodes.forEach(d=>{if(d.dataset.src){d.removeAttribute('data-processed');d.innerHTML='';d.textContent=d.dataset.src;}});
  window.mermaid.run({nodes}).catch(()=>{});}
-function renderMarkdown(el,text){el.innerHTML=text?marked.parse(text):'<span class="empty">empty body</span>';processMermaid(el);}
+function renderMarkdown(el,text){el.innerHTML=text?DOMPurify.sanitize(marked.parse(text)):'<span class="empty">empty body</span>';processMermaid(el);}
 
 /* ── inspector ── */
 const gbody=document.querySelector('.graph-body'), sideBody=document.getElementById('side-body');

data/lib/okf/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OKF
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/lib/okf.rb

@@ -4,7 +4,6 @@ require "erb"
 require "fileutils"
 require "date"
 require "json"
-require "optparse"
 require "pathname"
 require "securerandom"
 require "set"
@@ -50,6 +49,4 @@ module OKF
   require "okf/bundle/reader"
   require "okf/bundle/writer"
   require "okf/bundle/folder"
-  require "okf/skill"
-  require "okf/cli"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: okf
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Rodrigo Serradura
@@ -38,11 +38,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.4'
 description: |
-  OKF is portable knowledge — Markdown files with YAML frontmatter that both
-  humans and agents read. This gem reads OKF bundles, checks them for v0.1 (§9)
-  conformance, and serves them as an interactive graph (a mountable Rack app).
-  It ships a library API (OKF::Bundle and friends) plus an `okf` command-line
-  tool (validate / lint / loose / server / graph / skill).
+  OKF (Open Knowledge Format) is portable knowledge: Markdown files with YAML
+  frontmatter that both humans and agents read from one source. This gem is the
+  Ruby-native way to work with it. Its companion agent skill authors and curates
+  a bundle; the `okf` command-line tool validates the result for v0.1 (§9)
+  conformance, lints its curation quality, and serves it as an interactive graph
+  (a mountable Rack app). The same validate, lint, and graph run in-process
+  through a library API (OKF::Bundle and friends).
 email:
 - rodrigo.serradura@gmail.com
 executables:
@@ -138,5 +140,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.16
 specification_version: 4
-summary: Read, validate, and serve Open Knowledge Format (OKF) v0.1 bundles.
+summary: 'A lightweight Ruby gem for OKF: author, curate, and serve bundles as an
+  interactive graph.'
 test_files: []