Skip to content
Back to search

okf

OKF (Open Knowledge Format): Durable, structured memory for AI agents. Author, validate, consume, and maintain portable knowledge bundles through an ecosystem of Skills, MCP, an interactive graph, TUI, CLI, Docker, and a Claude Code plugin. 100% local.

Safety scan

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

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/serradura--okf/badge.svg)](/listings/serradura--okf)

HTML

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

Install

i

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 · 17 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "okfgem",
  3. "owner": {
  4. "name": "Rodrigo Serradura",
  5. "email": "rodrigo.serradura@gmail.com"
  6. },
  7. "metadata": {
  8. "description": "The okf gem's Claude Code plugin (okfgem.com): the OKF skill, a setup command, and deterministic bundle curation through the okf CLI."
  9. },
  10. "plugins": [
  11. {
  12. "name": "okf",
  13. "source": "./plugin",
  14. "description": "Open Knowledge Format: the OKF skill, /okf:gem setup and doctor, and a post-edit curation hook that runs the okf CLI's checks."
  15. }
  16. ]
  17. }
README.md · README · 393 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <p align="center">
  2. <a href="https://okfgem.com">
  3. <picture>
  4. <source media="(prefers-color-scheme: dark)" srcset=".github/hero-dark.png">
  5. <img src=".github/hero-light.png" width="100%" alt="okf: somewhere for your project's reasoning to live between agent sessions. Everything OKF, in one ecosystem: author, curate, and consume your project's knowledge, with your agent. 100% local. Start at https://okfgem.com/#try. The pieces, top to bottom: the Agent Skill (the brain) authors, curates and consumes, and writes the bundle (the memory) — Markdown + YAML, in your repo. The bundle is read by, and by nothing else, the library (the spine): require okf, the only thing that touches disk. Five surfaces sit over it — the CLI (the muscle) for validate, lint and search; the Graph (the vision), live or static; MCP (the nerve), any host, 14 tools; the TUI (the hands), six views over any bundle; and Pro (the guard), three doors, all of them closed. Available from RubyGems, as a Docker image, and as a Claude Code plugin, speaking OKF v0.2.">
  6. </picture>
  7. </a>
  8. </p>
  9. <p align="center">
  10. <a href="https://rubygems.org/gems/okf"><img src="https://img.shields.io/gem/v/okf" alt="Gem version"></a>
  11. <a href="https://rubygems.org/gems/okf"><img src="https://img.shields.io/gem/dt/okf" alt="Downloads"></a>
  12. <a href="https://github.com/serradura/okf/pkgs/container/okf"><img src="https://img.shields.io/badge/ghcr.io-okf-2496ED?logo=docker&logoColor=white" alt="Docker image"></a>
  13. <a href="https://github.com/serradura/okf/actions/workflows/main.yml"><img src="https://github.com/serradura/okf/actions/workflows/main.yml/badge.svg" alt="CI"></a>
  14. <a href="LICENSE.txt"><img src="https://img.shields.io/badge/license-Apache--2.0-blue" alt="License: Apache-2.0"></a>
  15. <a href="gems/okf/lib/okf/skill/reference/SPEC.md"><img src="https://img.shields.io/badge/OKF-v0.2-6E56CF" alt="OKF v0.2"></a>
  16. <a href="#claude-code-plugin"><img src="https://img.shields.io/badge/Claude%20Code-plugin-D97757" alt="Claude Code plugin"></a>
  17. </p>
  18. <p align="center">
  19. <b><a href="https://okfgem.com">Site</a></b> &nbsp;·&nbsp;
  20. <b><a href="https://okfgem.com/docs/">Docs</a></b> &nbsp;·&nbsp;
  21. <b><a href="https://demo.okfgem.com">Live demo</a></b> &nbsp;·&nbsp;
  22. <b><a href="https://claude.okfgem.com">Claude plugin</a></b> &nbsp;·&nbsp;
  23. <b><a href="https://docker.okfgem.com">Docker image</a></b>
  24. </p>
  25. Your coding agent works out how your system fits together — why the service
  26. exists, what the metric actually measures, which line of the schema is
  27. load-bearing — and then the session ends and all of it is gone. Next session it
  28. works the same things out again, from the same code, and reaches slightly
  29. different conclusions.
  30. **okf gives that reasoning somewhere to live.** Plain Markdown files in your
  31. repo, next to the code they explain, written and kept current by the agent
  32. itself rather than by you.
  33. It adds nothing to your stack. No database, no service, no new place to keep
  34. knowledge — just files, reviewed in the same pull request as the code. If you
  35. stop using okf tomorrow, everything it wrote is still Markdown your team can
  36. read.
  37. ### See it in sixty seconds
  38. This repository documents itself in OKF, so you can walk a real bundle before
  39. installing anything:
  40. ```bash
  41. gem install okf
  42. git clone https://github.com/serradura/okf && cd okf
  43. okf server .okf # the whole ecosystem as an interactive graph
  44. ```
  45. No Ruby on the machine? The published image runs the same commands —
  46. [docker.okfgem.com](https://docker.okfgem.com). Or skip the clone entirely and
  47. open [demo.okfgem.com](https://demo.okfgem.com).
  48. ### Why it doesn't rot
  49. Notes decay because keeping them current is a separate act from doing the work.
  50. Here it isn't:
  51. - **The agent writes it, not you.** An Agent Skill ships with the gem, so
  52. curation happens inside the work rather than after it.
  53. - **Drift is a failing build.** `okf validate` and `okf lint` return exit codes,
  54. so a stale or malformed bundle breaks CI the same way a broken test does.
  55. - **The agent reads only what it needs.** `okf index` reads the map and
  56. `okf search` pulls the handful of files a task touches, so the knowledge
  57. outgrows the context window instead of filling it.
  58. ### How it compares
  59. Knowledge already has several homes near an agent, and each holds something
  60. different. None of the others is built for curated, durable team knowledge:
  61. | | OKF bundle (this) | `CLAUDE.md` / `AGENTS.md` | Agent auto-memory | Wiki / Notion |
  62. | ------------------------------ | ----------------------------------------------------- | -------------------------- | ------------------------ | ---------------- |
  63. | Holds | curated team knowledge | standing instructions | what one agent picked up | human docs |
  64. | Versioned with the code | ✅ | ✅ | ❌ | ❌ |
  65. | Portable across agents | ✅ plain Markdown + YAML | ⚠️ per-harness conventions | ❌ per-agent store | ⚠️ export needed |
  66. | Typed and queryable | ✅ frontmatter + graph | ❌ prose | ❌ | ⚠️ partially |
  67. | Reviewed in PRs | ✅ | ✅ | ❌ implicit | ⚠️ rarely |
  68. | Scales past one context window | ✅ progressive disclosure<br>(`okf index` + `search`) | ❌ loaded whole | ⚠️ partially | n/a |
  69. | Checked by tooling | ✅ exit codes for CI<br>(`okf validate` + `lint`) | ❌ | ❌ | ❌ |
  70. The last two rows are this gem's job.
  71. [OKF][okf] is an open, vendor-neutral format (Google Cloud, 2026). This
  72. repository is a complete implementation of it, distributed as four gems, a
  73. Docker image, and a Claude Code plugin.
  74. [okf]: https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing
  75. ## What a bundle looks like
  76. A bundle is just a directory; each concept is one Markdown file whose path is its
  77. id. This repo documents _itself_ in OKF, so the tree below is real:
  78. ```
  79. .okf/
  80. ├── index.md # progressive-disclosure map (root carries okf_version)
  81. ├── log.md # ISO-dated change history, newest first
  82. ├── overview.md
  83. ├── gems/okf-mcp.md # one concept = one file
  84. ├── decisions/monorepo-layout.md
  85. └── format/frontmatter.md
  86. ```
  87. The only hard requirement is YAML frontmatter with a non-empty `type`; everything
  88. else is optional and tolerated when missing. A concept reads as below — this is
  89. the real `capabilities/graph-server.md` from the baseline gem's own bundle,
  90. `gems/okf/.okf/`, with its body trimmed:
  91. ```markdown
  92. ---
  93. type: Capability
  94. title: Interactive graph server (server)
  95. description: A self-contained HTML knowledge graph — served over HTTP as a mountable Rack app, one bundle or many behind a hub, or written to a single static file.
  96. resource: gems/okf/lib/okf/server/app.rb
  97. tags: [server, graph, rack, diagram]
  98. generated:
  99. by: human:maintainer
  100. at: 2026-08-13T12:00:00Z
  101. ---
  102. # Overview
  103. `okf server` boots an interactive view of the [graph](../model/graph.md) …
  104. ```
  105. The `.okf/` above is the **ecosystem's** map — a concept per gem, per plugin
  106. item, per skill — and each gem carries its own bundle beside its code. Clone the
  107. repo and run `okf server .okf` to browse the map as an interactive graph, or
  108. `okf server gems/okf/.okf` for the baseline gem's.
  109. ### Trust, provenance, and lifecycle — OKF v0.2
  110. Knowledge written continuously by agents raises questions a static corpus never
  111. had to answer: who wrote this, who checked it, is it still current? OKF v0.2
  112. makes them frontmatter — `generated` (who produced the content, and when),
  113. `verified` (who confirmed it, deriving the trust tier every surface shows:
  114. unverified · machine-confirmed · human-reviewed), `sources` with per-claim
  115. footnote attribution, `status`, and `stale_after` — and this gem reads all of
  116. it: as [catalog columns and `--status`/`--trust` filters](https://okfgem.com/docs/),
  117. as the [graph page](#the-graph)'s third visual channel, and as
  118. [lint](https://okfgem.com/docs/cli/lint/)'s provenance, attestation and
  119. migration findings. Every family is optional, and a v0.1 bundle keeps reading
  120. forever — two `lint` findings tell you exactly what a migration would change,
  121. and never fail you for not having done it.
  122. ## The whole ecosystem
  123. Knowledge an agent writes dies in four places, and a tool that fixes one of them
  124. only gets to watch it die in the next. **It never gets written**, because writing
  125. it up is a separate act from doing the work. **It rots**, and nothing says so
  126. until someone acts on a claim that stopped being true. **It cannot be found**,
  127. because the corpus outgrew the person who would have to read it all. And **it is
  128. stuck** in whichever tool wrote it, so the next tool starts over.
  129. The pieces below are one answer per failure. They are separate gems because they
  130. *install* separately, not because they are separate products: every one of them
  131. reads the same folder of Markdown, none of them is required by any other, and
  132. what you would lose by dropping all of them is tooling, never the knowledge.
  133. One install — `gem install okf` — carries three pieces:
  134. - an **Agent Skill**, so the knowledge gets written at all: your agent curates
  135. inside the work rather than promising to write it up afterwards, and you stay
  136. the editor;
  137. - a **CLI and Ruby library**, so you can ask the corpus a question instead of
  138. reading it — what is in here, which types and which tags, what links to what,
  139. what nothing links to, where the term you half-remember appears — and so drift
  140. is a failing build rather than a feeling: `validate` and `lint` answer with
  141. exit codes CI already knows how to fail on;
  142. - a **Graph**, so the shape of what the team knows is a thing you can look at —
  143. live on your machine, or one self-contained HTML file you can host anywhere or
  144. hand to someone who will never install this.
  145. Three sibling gems extend that same command rather than adding another one:
  146. - **`okf mcp`** ([okf-mcp](gems/okf-mcp/README.md)), so the knowledge is not stuck in whichever terminal wrote it: any MCP host reads it with no shell and nothing pasted into context — fourteen read tools, over stdio or Streamable HTTP;
  147. - **`okf tui`** ([okf-tui](gems/okf-tui/README.md)), so looking around costs a keystroke instead of four commands: six views over one bundle or every registered one, and you can read one while searching all of them;
  148. - **`okf pro`** ([okf-pro](gems/okf-pro/README.md)), so the practice holds on the days nobody is watching: it writes an agent's knowledge repository and then refuses to let it rot, at three doors that each fail closed.
  149. `gem install okf-pro` and you type `okf pro`. Packaging multiplies; the
  150. interface does not, and a sibling ships no second binary to learn.
  151. ### The second bundle costs nothing
  152. Nobody stops at one. The service you documented last month, the team handbook,
  153. the gem you maintain on the side — each is its own bundle in its own repository,
  154. and that is the right answer rather than a filing problem to clean up later.
  155. So a bundle gets a **name**. `okf registry set ./handbook` makes it `@handbook`,
  156. and anywhere a directory goes a `@slug` goes: `okf lint @handbook`, `okf render
  157. @handbook -o graph.html`. Groups collect the ones you think about together, and
  158. `@all` reaches every one you have registered — so the same four commands hold
  159. your whole corpus at once instead of one bundle of it:
  160. ```bash
  161. okf search @all "rate limit" # every bundle, ranked together in one list
  162. okf server # all of them behind one hub, in the browser
  163. okf tui # all of them in one terminal UI
  164. okf mcp # all of them, to any MCP host
  165. ```
  166. A project-local `.okf.json` replaces the machine-wide registry while you stand
  167. inside that repository. That is how this monorepo addresses its own five bundles
  168. as `@okf-eco`, `@okf`, `@okf-mcp`, `@okf-tui` and `@okf-pro` without anyone's
  169. `~/.okf` ever hearing about them.
  170. ## How the pieces fit together
  171. <p align="center">
  172. <picture>
  173. <source media="(prefers-color-scheme: dark)" srcset=".github/overview-dark.png">
  174. <img src=".github/overview-light.png" width="760" alt="The pieces, end to end: the Agent Skill (your coding agent authors and curates, you stay the editor) writes and maintains the bundle, a folder of Markdown + YAML in your repo where one concept is one file, links between files are the knowledge graph, and frontmatter says who wrote it, who checked it and when it goes stale. The bundle is read by — and by nothing else — the library (require okf), which reads, validates and indexes it and is the only thing that touches disk. Two surfaces come in the same install, gem install okf. The CLI, to ask the corpus and gate the merge: validate (legal OKF per section 11), lint (curated and fresh), search (find it, ranked), index / stats / types / tags (what is in here), registry (bundles addressed as @slug). The Graph, the shape of what the team knows: okf server (live), okf render (static HTML you can host anywhere), OKF::Server::App (the Rack app for one bundle), OKF::Server::Hub (the Rack app for every bundle), and untrusted bodies sanitized. Three more arrive through the plugin seam, each its own gem and no second binary. The MCP server (okf mcp, the okf-mcp gem): 14 read tools for any MCP host, reads and never writes, stdio or http with no CLI in the loop, every answer bounded for a context window. The Terminal UI (okf tui, the okf-tui gem): six views switched with number keys — bundles, browse, search, graph, health — read one while you search all of them, and the registry edited in place. OKF Pro (okf pro, the okf-pro gem): writes a whole knowledge repository, a board and a journal and a roadmap, held at three doors — agent, commit, CI — every one of which fails closed. The CLI runs the checks and retrieves the data the Agent Skill acts on. 100% local, Ruby 2.4 or newer, only rack, webrick and minifts as dependencies, Apache-2.0.">
  175. </picture>
  176. </p>
  177. _Everything above the first divider is what one `gem install okf` gives you.
  178. Everything below it arrives through the same plugin seam, one gem at a time, and
  179. every door is listed in
  180. [What is in this repository](#what-is-in-this-repository)._
  181. > [!TIP]
  182. > **Browse this repository as knowledge, not just docs.** This README is the
  183. > front door; the depth lives in the five OKF bundles it carries. Start at the
  184. > [ecosystem map](.okf) — the [gems](.okf/gems/), the [plugin](.okf/plugin/),
  185. > the [skills](.okf/skills/), the [decisions](.okf/decisions/) and the
  186. > [format itself](.okf/format/) — then open a gem's own bundle for its code:
  187. > [`gems/okf/.okf/`](gems/okf/.okf). Run `okf server .okf` to walk the map as an
  188. > interactive graph, or `okf search @all <term>` to reach every bundle at once.
  189. **It installs on the Ruby your OS already ships** — every Ruby since 2.4, three
  190. small dependencies, no native extension and no build step — so there is nothing
  191. to provision and nothing to keep up to date. The
  192. [design constraints](gems/okf/.okf/design/) that hold that line are enforced by
  193. tests on every supported Ruby.
  194. ## What is in this repository
  195. Every top-level name is a boundary, and the whole menu is one row each. A
  196. directory under `gems/` is a gem, named for the gem it ships; everything else at
  197. the root is named for what it is.
  198. | Door | What lives there |
  199. | ---- | ---------------- |
  200. | [`gems/okf/`](gems/okf/README.md) | the `okf` gem — the agent skill, the CLI and library, ranked search, the graph. Everything above describes this one |
  201. | [`gems/okf-mcp/`](gems/okf-mcp/README.md) | `okf mcp` — the MCP server over the same kernel: 14 read tools, any MCP host |
  202. | [`gems/okf-tui/`](gems/okf-tui/README.md) | `okf tui` — the full-screen terminal UI, over one bundle or every registered one |
  203. | [`gems/okf-pro/`](gems/okf-pro/README.md) | `okf pro` — writes an agent's knowledge repository, then enforces it at three doors |
  204. | [`plugin/`](#claude-code-plugin) | the Claude Code plugin: that skill, `/okf:gem`, and a post-edit curation hook |
  205. | [`.claude-plugin/`](.claude-plugin) | the marketplace manifest — this repository is its own marketplace |
  206. | [`skills/`](#the-skill-without-the-gem) | the skills a generic installer reads: `okf`, and `okf-principles` |
  207. | [`resources/`](resources/ci/github/README.md) | copy-paste recipes — today, CI that validates and lints your bundles on every push |
  208. | [`.okf/`](.okf) | the ecosystem map: a concept per gem, per plugin item, per skill — plus the decisions and the format |
  209. | [`.okf.json`](.okf.json) | every bundle in this tree, addressable as `@slug` from anywhere in it |
  210. | [`Dockerfile`](Dockerfile) | builds the published image from `gems/okf/`, from a root build context |
  211. | [`.github/`](.github/workflows) | the CI workflows, and the images this page renders |
  212. | [`.claude/`](.claude/CLAUDE.md) | one line, pointing Claude Code at [`AGENTS.md`](AGENTS.md) |
  213. ## The graph
  214. <picture>
  215. <source media="(prefers-color-scheme: dark)" srcset=".github/server-dark.png">
  216. <img src=".github/server-light.png" alt="The okf graph server: a force-directed knowledge graph with a concept selected, its neighbors highlighted and the rest of the bundle dimmed, and the inspector panel showing the concept's type, description, tags, and every concept it links to and from, each labelled with its type.">
  217. </picture>
  218. _The graph server on this repo's own [`.okf`](.okf) bundle, with the `overview`
  219. concept selected. Try it live at
  220. **[demo.okfgem.com](https://demo.okfgem.com)**._
  221. What the page does, and how `okf render` bakes the same thing into one static
  222. file: [`gems/okf/README.md`](gems/okf/README.md#the-graph).
  223. ## Claude Code plugin
  224. This repository doubles as a Claude Code plugin marketplace, so the whole
  225. toolchain installs with two commands inside Claude Code:
  226. ```
  227. /plugin marketplace add serradura/okf
  228. /plugin install okf@okfgem
  229. ```
  230. The plugin carries three pieces: the [`okf` skill](gems/okf/README.md#the-agent-skill);
  231. **`/okf:gem`**, a front door that hands its arguments to the skill unchanged (no
  232. arguments: it orients on your bundle and recommends the next move, never
  233. auto-runs); and a **curation hook** that runs `okf validate` + `okf lint` after
  234. every edit inside a bundle and returns the findings as context. The checks are
  235. the CLI's own, so the feedback is deterministic.
  236. The hook stays silent outside bundles, and it is config-free to switch off:
  237. `OKF_CURATE_DISABLED=1` turns it off, `OKF_CURATE_QUIET=1` keeps the findings
  238. without the install suggestion, and an `<!-- okf-disable -->` comment skips one
  239. file.
  240. Prefer no plugin? `gem install okf && okf skill .claude` installs the skill
  241. alone, and the skill itself instructs the agent to run the same checks after
  242. editing a bundle.
  243. ## The skill, without the gem
  244. **Without the gem**, any agent that reads `SKILL.md` installs it straight from
  245. this repository:
  246. ```bash
  247. npx skills add serradura/okf # choose from the list
  248. npx skills add serradura/okf --skill okf -a codex # or name skill and agent
  249. ```
  250. That path installs a generated copy — `rake skill:sync` writes it from the same
  251. canonical tree the gem ships, and the build fails on any drift — so it tracks
  252. this repository rather than the `okf` on your machine. `okf-principles` sits
  253. beside it: the five structural principles the format implies, written to be
  254. pointed at any instruction artifact rather than at a bundle.
  255. ## Extending okf, and running it safely
  256. Publish a gem named `okf-*` carrying an `okf/plugin.rb` and installing it is the
  257. whole installation: your verb answers to `okf` and behaves like a built-in.
  258. Nothing an addon registers can displace one, and a broken addon is skipped rather
  259. than taking the CLI down. The three siblings above arrive exactly this way —
  260. `okf-mcp`, `okf-tui` and `okf-pro` each ship an `okf/plugin.rb` and no
  261. executable of their own — and none of them needs a line of the baseline to know
  262. it exists. Yours would be the fourth, on the same terms.
  263. Contract and threat model:
  264. [extension points](.okf/design/extension-points.md).
  265. The graph page treats a bundle as untrusted content: inlined data is escaped, and
  266. every concept body is sanitized before it reaches the DOM, so a script hidden in
  267. Markdown is stripped rather than run. It still loads libraries from a CDN, so
  268. treat an unfamiliar bundle the way you would treat any document from a source you
  269. do not know. Full write-up:
  270. [server trust boundary](gems/okf/.okf/design/server-trust-boundary.md).
  271. ## Development
  272. From the repo root — plain `rake`, there is no root Gemfile:
  273. ```bash
  274. rake # every gem's default task (tests + RuboCop), then the repo-level lint
  275. rake test # every gem's test suite
  276. rake okf # validate + lint every registered .okf bundle
  277. rake serve # browse this project's own bundle as a graph
  278. ```
  279. From any gem's directory, for work on that gem — `cd gems/okf-mcp`, `cd
  280. gems/okf-tui` or `cd gems/okf-pro` follows the same three commands, and each has
  281. its own README and CI job. From `gems/okf`, for work on the baseline itself:
  282. ```bash
  283. cd gems/okf
  284. bin/setup # install dependencies
  285. bundle exec rake # tests + RuboCop (what CI runs)
  286. bundle exec rake test # just the test suite
  287. ruby -Ilib exe/okf validate <dir> # run the CLI from a checkout
  288. ```
  289. The suite runs on every supported Ruby; to check the 2.4 floor locally, from the
  290. repo root:
  291. ```bash
  292. docker run --rm -v "$PWD":/src:ro ruby:2.4 bash -c \
  293. "cp -a /src /build && cd /build/gems/okf && rm -f Gemfile.lock && bundle install --quiet && bundle exec rake test"
  294. ```
  295. The graph page has its own suite in a real browser (`bundle exec rake
  296. browser:setup`, then `rake test:browser`, both from `gems/okf/`). See
  297. [AGENTS.md](AGENTS.md) for the maintainer guide.
  298. ## Contributing
  299. Bug reports and pull requests are welcome on GitHub at
  300. <https://github.com/serradura/okf>. This project is intended to be a safe,
  301. welcoming space for collaboration, and contributors are expected to adhere to
  302. the [code of conduct](CODE_OF_CONDUCT.md).
  303. ## License
  304. The gem is available as open source under the terms of the
  305. [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0) (see
  306. `LICENSE.txt`). The Open Knowledge Format specification bundled with the skill
  307. is authored by Google Cloud Platform and included under its own Apache-2.0
  308. license, Copyright (c) Google LLC. See `NOTICE` and
  309. `okf/lib/okf/skill/reference/APACHE-2.0.txt`.
  310. [okf-skills](https://github.com/scaccogatto/okf-skills) by Marco Boffo, a Python
  311. OKF toolkit for Claude Code with a feature-rich interactive graph view, was an
  312. early inspiration for this gem's Claude Code plugin and for the knowledge-as-code
  313. comparison in [How it compares](#how-it-compares). okf takes a different shape: a Ruby-native
  314. gem built around the `okf` CLI and an embeddable library.

Ratings and comments

Sign in to rate this skill.

Sign in

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