Skip to content
Back to search

vault-generator

MarketplaceWorks with Claude CodeGitHub

Agent Skill that turns a codebase or documentation set into an indexed Obsidian knowledge vault and retrieves only what a task needs.

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/dani-b-g--vault-generator/badge.svg)](/listings/dani-b-g--vault-generator)

HTML

<a href="/listings/dani-b-g--vault-generator"><img src="/api/listings/dani-b-g--vault-generator/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.

**Requirements:** Node.js **22.18 or newer**, plus [Claude Code](https://code.claude.com) and/or the [Codex CLI](https://developers.openai.com/codex). Nothing else needs to be installed: the two small parsers the engine uses are bundled.

**In Claude Code**, install it as a plugin (one command, no clone):

/plugin install vault-generator --marketplace dani-b-g/vault-generator

**In Codex, or to commit the skill with your project**, use the installer:

git clone https://github.com/dani-b-g/vault-generator.git
cd vault-generator

# install the skill into the project you want to document (for Claude Code and Codex)
node skills/vault-generator/scripts/install.ts --target /path/to/your/project --agent both

Then, in the project you want to document:

/vault-generator          ← Claude Code
$vault-generator          ← Codex

With no arguments the skill analyses the directory, shows you what it found and the evidence for it, asks what it cannot determine, previews the notes it would create, and generates the vault (by default in `knowledge-vault/`) once you agree.

To make the skill available in every project instead, use `--global`. It installs into `~/.claude/skills` and `~/.agents/skills`. [Installation](#installation) covers every option. The next section, [Using the skill](#using-the-skill), lists every operation you can run.

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 · 23 lines
  1. {
  2. "name": "vault-generator",
  3. "description": "Agent Skill that turns a codebase or documentation set into an indexed Obsidian knowledge vault and retrieves only what a task needs.",
  4. "owner": {
  5. "name": "vault-generator contributors",
  6. "url": "https://github.com/dani-b-g/vault-generator"
  7. },
  8. "plugins": [
  9. {
  10. "name": "vault-generator",
  11. "source": "./skills/vault-generator",
  12. "description": "Builds and maintains an indexed, navigable Obsidian knowledge vault from any codebase or documentation, and retrieves only the knowledge relevant to a question or task. Runs locally on Node.js 22.18+, with no network access.",
  13. "author": {
  14. "name": "vault-generator contributors"
  15. },
  16. "homepage": "https://github.com/dani-b-g/vault-generator",
  17. "repository": "https://github.com/dani-b-g/vault-generator",
  18. "license": "Apache-2.0",
  19. "keywords": ["obsidian", "knowledge-base", "documentation", "codebase", "retrieval"],
  20. "category": "documentation"
  21. }
  22. ]
  23. }
README.md · README · 902 lines
  1. # vault-generator
  2. **English** | **[Español](README.es.md)**
  3. **An Agent Skill that turns any codebase or documentation set into an indexed Obsidian knowledge vault — and lets AI agents retrieve only what a task needs.**
  4. [![License: Apache-2.0](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
  5. ![Node.js ≥ 22.18](https://img.shields.io/badge/node-%E2%89%A5%2022.18-339933.svg)
  6. ![Agents: Claude Code · Codex](https://img.shields.io/badge/agents-Claude%20Code%20%C2%B7%20Codex-6f42c1.svg)
  7. ![Runtime dependencies: none to install](https://img.shields.io/badge/runtime%20deps-none%20to%20install-success.svg)
  8. `vault-generator` follows the open [Agent Skills](https://agentskills.io/specification) format. You invoke it from
  9. your coding agent (`/vault-generator` in Claude Code, `$vault-generator` in Codex). It analyses the projects,
  10. packages, documentation and configuration in front of it, then builds an
  11. [Obsidian](https://obsidian.md) vault. Every note cites its sources, carries a stable identifier and links to related
  12. notes. The vault stays in sync as the code changes. Agents (and people) can then ask it focused questions instead of
  13. reading the whole repository.
  14. > **Status:** early release (`1.0.0`). The engine and its 51 automated tests run locally on Node.js. See
  15. > [Limitations](#limitations) before relying on it for large or unusual codebases.
  16. ---
  17. ## Contents
  18. - [Why](#why)
  19. - [What it does](#what-it-does)
  20. - [Quick start](#quick-start)
  21. - [Using the skill](#using-the-skill)
  22. - [Installation](#installation)
  23. - [Example](#example)
  24. - [How it works](#how-it-works)
  25. - [What it guarantees](#what-it-guarantees)
  26. - [Security and privacy](#security-and-privacy)
  27. - [Supported sources](#supported-sources)
  28. - [Reference](#reference)
  29. - [Configuration](#configuration)
  30. - [Extending](#extending)
  31. - [Limitations](#limitations)
  32. - [Roadmap](#roadmap)
  33. - [Development](#development)
  34. - [Contributing](#contributing)
  35. - [License](#license)
  36. ---
  37. ## Why
  38. Coding agents work best with the right context and worst with too much of it. In a real repository, the knowledge an
  39. agent needs is scattered across READMEs, generated API docs, OpenAPI specs, manifests, decision records and the code
  40. itself. Pasting all of it into a prompt is expensive and noisy. Leaving it out leads to invented APIs.
  41. `vault-generator` builds that knowledge base once, keeps it current, and answers with **cited fragments within a
  42. token budget**. It also states plainly when the vault does not know something.
  43. ## What it does
  44. - **Understands the workspace before touching it.** It works out whether it is looking at a single project, a
  45. monorepo, several repositories, a documentation site or an existing vault. It identifies projects and packages from
  46. their manifests (not folder names), builds the internal dependency graph, and notices when you are inside a larger
  47. workspace.
  48. - **Generates an Obsidian vault whose structure comes from the sources.** The layout is flat, by category or by
  49. project, depending on what was found. Notes carry YAML properties, wikilinks, tags, aliases, maps of content, Mermaid
  50. diagrams and attachments.
  51. - **Keeps provenance and evidence.** Every note lists the files it came from (with content hashes). Every relation
  52. between projects, modules, APIs and documents carries the evidence behind it, and inferred relations are never
  53. presented as facts.
  54. - **Syncs incrementally without overwriting your work.** Only changed sources are reprocessed. Your edits are kept or
  55. merged, conflicts are saved aside instead of resolved silently, and every run can be undone.
  56. - **Retrieves selectively.** A local SQLite full-text index over sections, symbols, API operations and relations
  57. powers `search` and task-specific `context` packages for agents.
  58. - **Transforms and exports.** It converts HTML to Markdown, OpenAPI to an API reference, code to an API reference and
  59. Obsidian notes to CommonMark. It exports the vault as a static site, a single Markdown bundle, an agent context
  60. package or a brand-new Agent Skill.
  61. - **Generates grounded examples.** Code examples and small demo apps only use APIs documented in the vault, and they
  62. are never reported as validated unless they were actually run.
  63. - **Asks instead of guessing.** Scope, destination, contradictory documentation, the default version, restricted
  64. content and example requirements are all asked about. Answers are remembered.
  65. ## Quick start
  66. **Requirements:** Node.js **22.18 or newer**, plus [Claude Code](https://code.claude.com) and/or the
  67. [Codex CLI](https://developers.openai.com/codex). Nothing else needs to be installed: the two small parsers the
  68. engine uses are bundled.
  69. **In Claude Code**, install it as a plugin (one command, no clone):
  70. ```text
  71. /plugin install vault-generator --marketplace dani-b-g/vault-generator
  72. ```
  73. **In Codex, or to commit the skill with your project**, use the installer:
  74. ```sh
  75. git clone https://github.com/dani-b-g/vault-generator.git
  76. cd vault-generator
  77. # install the skill into the project you want to document (for Claude Code and Codex)
  78. node skills/vault-generator/scripts/install.ts --target /path/to/your/project --agent both
  79. ```
  80. Then, in the project you want to document:
  81. ```text
  82. /vault-generator ← Claude Code
  83. $vault-generator ← Codex
  84. ```
  85. With no arguments the skill analyses the directory, shows you what it found and the evidence for it, asks what it
  86. cannot determine, previews the notes it would create, and generates the vault (by default in `knowledge-vault/`) once
  87. you agree.
  88. To make the skill available in every project instead, use `--global`. It installs into `~/.claude/skills` and
  89. `~/.agents/skills`. [Installation](#installation) covers every option. The next section, [Using the skill](#using-the-skill),
  90. lists every operation you can run.
  91. ## Using the skill
  92. `vault-generator` is one skill with one entry point. There are no separate sub-skills to install or call. What you can
  93. run are its **operations** (the engine calls them *modes*): sixteen of them, from `analyze` to `export`. The agent picks
  94. the right operation from your request and asks you for anything it cannot decide.
  95. ### Three ways to ask
  96. | Style | Example | What happens |
  97. | --- | --- | --- |
  98. | No arguments | `/vault-generator` | Analyses the directory (or reports what changed, if a vault already exists), asks what it cannot decide, previews the notes and generates once you agree |
  99. | Natural language, English or Spanish | `/vault-generator where is the session token validated?` | The agent maps the request to an operation |
  100. | Explicit operation | `$vault-generator --mode search "retry policy" --project @acme/http` | Your flags are passed to the engine as given |
  101. In the commands below, `vg` stands for `node <skill-dir>/scripts/vg.mjs`, the engine the agent runs for you.
  102. `<skill-dir>` is `.claude/skills/vault-generator` (or `.agents/skills/vault-generator`) after a project installation.
  103. You can run `vg` yourself too. [Running the engine yourself](#running-the-engine-yourself) covers the output format
  104. and exit codes.
  105. ### Operations
  106. | Group | Operation | Purpose | Writes files |
  107. | --- | --- | --- | --- |
  108. | Build and maintain | `analyze` | Detect the context (single project, monorepo, several repositories, docs site, existing vault) and propose a strategy | no |
  109. | | `generate` | Build the vault from the selected sources | yes |
  110. | | `sync` | Incremental update after the sources change | yes |
  111. | | `status` | What changed since the last run: sources, hand-edited notes, open conflicts | no |
  112. | Find knowledge | `search` | Selective retrieval, with filters | no |
  113. | | `context` | Task-specific context package for an agent, within a token budget | no (unless `--output`) |
  114. | Check and repair | `validate` | Check structure, metadata, identifiers, links and the index | no |
  115. | | `reorganize` | Evaluate the vault structure; `--apply` moves notes (with backups) | only with `--apply` |
  116. | | `conflicts` | List sync conflicts and resolve them | only with `--resolve` |
  117. | | `restore` | List backups and undo a run | only with `--run` |
  118. | | `index` | Update or rebuild the search index | yes (the index) |
  119. | Convert and export | `transform` | Convert files between formats | yes |
  120. | | `export` | Static site, Markdown bundle, agent context or a new Agent Skill | yes |
  121. | | `examples` | Code examples and demo apps grounded in documented APIs | yes, outside the vault |
  122. | Inspect the installation | `capabilities` | Analyzers, transformers and formats actually installed | no |
  123. | | `validate-skill` | Check an Agent Skill directory against the specification | no |
  124. With no operation given, `vg` runs `status` when it finds a managed vault and `analyze` otherwise. `vg sync` works as
  125. well as `vg --mode sync`.
  126. ### Build and maintain
  127. ```text
  128. /vault-generator analyze this repository
  129. /vault-generator generate a vault only for packages/core and its dependencies
  130. /vault-generator sync the vault, I changed the API
  131. /vault-generator what changed since the last run?
  132. $vault-generator sincroniza el vault
  133. ```
  134. ```sh
  135. vg --mode analyze # read-only: what is here and what would be asked
  136. vg --mode generate --dry-run # preview the notes, write nothing
  137. vg --mode generate --answer destination=default # write the vault (first run asks where to put it)
  138. vg --mode status # sources added, modified or removed since the last run
  139. vg --mode sync # bring the vault up to date
  140. ```
  141. | Operation | Options | Notes |
  142. | --- | --- | --- |
  143. | `generate` | `--source`, `--scope`, `--vault`, `--depth`, `--language`, `--dry-run`, `--answer` | Blocking questions stop the run before anything is written. The first run asks where to create the vault (default `knowledge-vault/`) |
  144. | `sync` | `--on-conflict save-both\|keep-mine\|take-source` (default `save-both`), `--prune-stale`, `--trust-plugins` | Reports counts, conflicts, API contract changes and structural changes. Notes whose source disappeared are flagged stale; `--prune-stale` moves them to `.vault-generator/trash/` |
  145. | `analyze`, `status` | | Read-only. Without a vault, `status` falls back to `analyze` |
  146. Common scopes:
  147. ```sh
  148. vg --mode generate # the whole project or monorepo
  149. vg --mode generate --scope packages/core # part of a monorepo (+ its internal dependencies)
  150. vg --mode generate --source ../frontend --source ../backend # several repositories in one vault
  151. vg --mode generate --source ./docs-site # documentation only
  152. vg --mode generate --source ../project --vault ~/MyVault # into an existing Obsidian vault
  153. ```
  154. ### Find knowledge
  155. ```text
  156. /vault-generator where is the session token validated?
  157. /vault-generator prepare context to add pagination to the /orders endpoint
  158. ```
  159. ```sh
  160. vg --mode search "retry policy" --project @acme/http --type document --limit 5
  161. vg --mode search --note "api-client" --section "Public API" # read one section of one note
  162. vg --mode context "add pagination to the /orders endpoint" --budget 3000
  163. vg --mode context "add pagination to the /orders endpoint" --output context/orders # also writes orders.md and .json
  164. ```
  165. | Operation | Options |
  166. | --- | --- |
  167. | `search` | `--project`, `--type project\|module\|api\|document\|decision\|example\|operations\|moc`, `--tech`, `--version` (`any` searches every version), `--tag`, `--status`, `--limit` (default 8). `--note <path or title>` with `--section <heading>` reads one section |
  168. | `context` | `--project`, `--version`, `--budget` in tokens (default 6000), `--limit` notes (default 8), `--format markdown\|json`, `--output <file>` |
  169. Prefer `context` when you are about to implement, fix, test or migrate something. It returns cited fragments within the
  170. budget, related notes, constraints and explicit uncertainties. `search` is for looking something up. Every hit says
  171. which note and lines it came from, its sources and how confident the match is. When nothing matches, `search` exits
  172. with code `3`: the vault does not cover it, so look at the source code.
  173. ### Check and repair
  174. ```sh
  175. vg --mode validate # errors fail with exit code 2
  176. vg --mode validate --check-sources # also check that every cited source file still exists
  177. vg --mode reorganize # proposal only: orphans, oversized folders, ambiguous names
  178. vg --mode reorganize --apply --answer reorganize-confirm=yes # apply the moves (backed up, links rewritten)
  179. vg --mode conflicts # open conflicts, with a diff of both versions
  180. vg --mode conflicts --resolve <conflict-id> --take mine # or source, or merged (you removed the markers by hand)
  181. vg --mode restore # list backup runs
  182. vg --mode restore --run <runId> --dry-run # preview undoing a run; drop --dry-run to do it
  183. vg --mode index --rebuild # recreate the search index (also works on any Obsidian vault)
  184. ```
  185. `validate` errors mean broken metadata, identifiers, markers or links, or a leaked secret or private path. Fix them
  186. by running `sync` or `index`, not by editing the generated blocks. `reorganize --apply` and `restore` are themselves
  187. backed up, so both can be undone.
  188. ### Convert and export
  189. ```text
  190. /vault-generator export the vault as an HTML site
  191. /vault-generator export a skill with the orders documentation
  192. ```
  193. `transform` converts files that are not in the vault. The transformer is inferred from the input unless you name one
  194. with `--transformer`:
  195. | Input | Transformer | Result |
  196. | --- | --- | --- |
  197. | `.html` file, or a folder of HTML (including generated docs sites) | `html-to-markdown` | Markdown without the navigation chrome |
  198. | OpenAPI or Swagger `.json` / `.yaml` | `openapi-to-markdown` | An API reference |
  199. | Source code file or folder | `code-to-markdown` | An API reference of the public surface |
  200. | Obsidian `.md` note | `obsidian-to-commonmark` | Portable CommonMark (wikilinks and callouts converted) |
  201. ```sh
  202. vg --mode transform --input docs-site/ --output docs-md
  203. vg --mode transform --input openapi.yaml
  204. vg --mode transform --input note.md --transformer obsidian-to-commonmark
  205. ```
  206. `export` turns the vault itself into something else:
  207. | `--to` | Creates | Default location | Extra options |
  208. | --- | --- | --- | --- |
  209. | `html` | A static site with resolved links and a title search | `<vault>/.vault-generator/exports/site/` | `--project`, `--type`, `--tag` |
  210. | `bundle` | One portable Markdown file | `<vault>/.vault-generator/exports/bundle.md` | `--project`, `--type`, `--tag` |
  211. | `context` | A task-specific context package (Markdown and JSON) | `<vault>/.vault-generator/exports/context-<task>.md` and `.json` | `--task "<goal>"`, `--budget`, `--project`, `--type`, `--version` |
  212. | `skill` | A new Agent Skill (`SKILL.md` plus one reference file per note) | `./<name>/` | `--name <skill-name>` (required; lowercase letters, digits and single hyphens), `--project`, `--type`, `--tag` |
  213. ```sh
  214. vg --mode export --to html
  215. vg --mode export --to bundle --output out/vault.md
  216. vg --mode export --to context --task "add pagination to /orders" --output out/orders-context
  217. vg --mode export --to skill --name orders-kb --project @acme/orders
  218. ```
  219. Every `transform` and `export` reports its validations and anything lost in the conversion. `transform`,
  220. `export --to bundle`, `export --to skill` and `examples` refuse to overwrite an existing output unless you pass
  221. `--force`. `export --to html` and `export --to context` refresh the output they created earlier, and `html` refuses a
  222. folder it did not create. Restricted notes are left out unless you pass `--include-restricted`.
  223. `examples` writes code that only uses APIs documented in the vault:
  224. ```sh
  225. vg --mode examples --project @acme/http --goal "retry a failed request" --kind snippet
  226. vg --mode examples --project @acme/http --goal "paginate orders" --kind app --validate
  227. ```
  228. | Option | Meaning |
  229. | --- | --- |
  230. | `--project`, `--goal`, `--kind snippet\|app` | What to build. Anything missing comes back as a question |
  231. | `--output <dir>` | Where to write it (default `examples/<project>-<goal>`, outside the vault) |
  232. | `--validate` | For a Node.js app, run `npm install` and start it. Without it only a syntax check runs |
  233. | `--force` | Overwrite an existing example |
  234. An example is never reported as validated unless its checks ran and passed.
  235. ### Inspect the installation
  236. ```sh
  237. vg --mode capabilities # analyzers, transformers, formats, plugins, search index
  238. vg --mode validate-skill --skill-dir .claude/skills/vault-generator
  239. ```
  240. ### Options shared by every operation
  241. | Option | Meaning |
  242. | --- | --- |
  243. | `--source <path>` | Source directory or file. Repeatable or comma separated. Default: the current directory, or the sources stored in the vault |
  244. | `--scope <project>` | Limit to projects (id, name, path or glob). Internal dependencies are added automatically; `--answer scope-deps=exclude` keeps them as overview only |
  245. | `--vault <dir>` | Vault directory. Default: the managed vault in or below the current directory, otherwise `<source>/knowledge-vault` |
  246. | `--answer <id>=<value>` | Answer a question from a previous run. Repeatable. Stored in the vault, never asked again |
  247. | `--depth shallow\|standard\|deep` | How much code detail goes into the notes (25, 80 or 400 symbols per module) |
  248. | `--language en\|es` | Language of generated headings and labels (detected from the READMEs when not set) |
  249. | `--dry-run` | Compute everything, write nothing, report the plan |
  250. | `--include-restricted` | Include restricted notes in search, context and export. Use it only on purpose |
  251. | `--config <file>`, `--cwd <dir>` | A configuration file; run as if from another directory |
  252. | `--json`, `--verbose` | Machine-readable output; more detail (and stack traces on errors) |
  253. ### Questions the skill asks
  254. When a decision changes the result and the sources cannot settle it, the engine returns a question instead of
  255. guessing. A blocking question stops the run before anything is written (exit code `10`). Answer it in the chat, or add
  256. `--answer <id>=<value>` and run the same command again. Optional questions do not block: they are mentioned in the
  257. summary and can be answered on the next `sync`.
  258. | Question | When | Options |
  259. | --- | --- | --- |
  260. | `destination` | The first `generate` | `default` (the proposed path) or any path |
  261. | `vault-placement` | The destination already holds notes not created by this tool | `subfolder`, `root`, `cancel` |
  262. | `scope` | More than 12 projects, or several unrelated ones with no workspace tool | `all`, or project ids |
  263. | `restricted-docs` | Documents look private | `exclude`, `restricted`, `public` |
  264. | `reorganize-confirm` | `reorganize --apply` has moves to make | `yes`, `no` |
  265. Contradictions between sources, relations inferred from patterns and the default documentation version are optional
  266. questions. [questions.md](skills/vault-generator/references/questions.md) lists every question and what each answer
  267. does.
  268. ### Typical workflows
  269. ```sh
  270. # First time
  271. vg --mode analyze # what is here?
  272. vg --mode generate --dry-run # what would be written?
  273. vg --mode generate --answer destination=default # write it
  274. vg --mode validate
  275. # After changing code or docs
  276. vg --mode status
  277. vg --mode sync
  278. # Before working on a task
  279. vg --mode context "add a getProduct function to the api client" --budget 1200
  280. # Share it
  281. vg --mode export --to html
  282. ```
  283. ### Running the engine yourself
  284. `vg` takes `--mode <operation>` (or the operation as the first word) and, optionally, a request in plain words. With
  285. `--json` every call returns the same envelope, which is what the agent reads:
  286. ```json
  287. { "ok": true, "mode": "generate", "status": "done", "summary": "...", "data": {}, "questions": [], "warnings": [], "next": [] }
  288. ```
  289. `status` is `done`, `needs_input`, `dry_run` or `error`, and `next` suggests the follow-up command.
  290. | Exit code | Meaning |
  291. | --- | --- |
  292. | `0` | Success |
  293. | `1` | Error, such as an unknown mode, a bad option or an output that already exists |
  294. | `2` | `validate` found errors |
  295. | `3` | Nothing found (`search`) |
  296. | `4` | Note or section not found (`search --note`) |
  297. | `10` | Needs input: read `questions` and answer with `--answer` |
  298. Without `--mode`, `vg "where is the retry policy documented?"` picks an operation from keywords in English or Spanish
  299. (`sincroniza` runs `sync`, a question runs `search`) and says which one it chose in `warnings`. Agents choose the
  300. operation themselves, so use `--mode` in scripts. The complete option reference is
  301. [operations.md](skills/vault-generator/references/operations.md).
  302. ## Installation
  303. There are two ways to install it: as a **Claude Code plugin** (one command, Claude Code only), or with the
  304. **installer**, which copies the skill into your project or home directory for Claude Code and Codex. Steps 1 to 4 below
  305. cover the installer; step 1 (the requirements) applies to both.
  306. ### Install as a Claude Code plugin
  307. This repository is also a Claude Code plugin marketplace, so Claude Code can fetch, install and update the skill by
  308. itself: no clone and no installer. It still needs Node.js 22.18 or newer.
  309. ```text
  310. /plugin install vault-generator --marketplace dani-b-g/vault-generator
  311. ```
  312. Claude Code asks you to confirm the marketplace, then lets you choose a scope: just you in every project (`user`),
  313. everyone who works in a repository (`project`) or just you in one repository (`local`). From a shell, without starting
  314. a session (Claude Code 2.1.292 or later):
  315. ```sh
  316. claude plugin install vault-generator --marketplace dani-b-g/vault-generator
  317. ```
  318. On older versions, add the marketplace first and then install:
  319. ```text
  320. /plugin marketplace add dani-b-g/vault-generator
  321. /plugin install vault-generator@vault-generator
  322. ```
  323. Check it:
  324. ```sh
  325. claude plugin list # vault-generator@vault-generator, Status: enabled
  326. claude plugin details vault-generator
  327. ```
  328. The skill answers to `/vault-generator` and to `/vault-generator:vault-generator`. If it does not appear, run
  329. `/reload-plugins` or restart Claude Code, and look at the **Errors** tab of `/plugin`.
  330. How it differs from the installer:
  331. - **Claude Code only.** The plugin is for Claude Code. For Codex, use the installer.
  332. - **Managed by Claude Code.** The copy lives under `~/.claude/plugins/`; do not edit it. With user scope nothing is
  333. added to your project. To give a team the skill, either install with `--scope project` (every teammate still runs the
  334. install once) or use the installer and commit `.claude/skills/`.
  335. - **Updates.** Claude Code does not auto-update third-party marketplaces unless you turn it on (`/plugin`, then
  336. **Marketplaces**). Update by hand with `claude plugin update vault-generator@vault-generator`. The plugin version
  337. follows the commits of this repository.
  338. - **Uninstall.** `claude plugin uninstall vault-generator@vault-generator`. Add
  339. `claude plugin marketplace remove vault-generator` to drop the marketplace as well.
  340. ### 1. Check the requirements
  341. ```sh
  342. node --version # must print v22.18.0 or newer
  343. ```
  344. | Requirement | Version | Why |
  345. | --- | --- | --- |
  346. | Node.js | 22.18 or newer | Runs the TypeScript engine directly and provides the built-in SQLite search index |
  347. | Claude Code and/or Codex CLI | current | To invoke the skill from an agent (`/vault-generator`, `$vault-generator`) |
  348. | Git | any | Only to clone this repository; any download of the files works too |
  349. | Python 3 | optional | Only to syntax-check generated Python examples |
  350. There is no `npm install` step. Everything the skill needs at runtime is in `skills/vault-generator/`, including the
  351. two bundled parsers. No environment variables or accounts are needed.
  352. ### 2. Get the skill
  353. ```sh
  354. git clone https://github.com/dani-b-g/vault-generator.git
  355. cd vault-generator
  356. ```
  357. ### 3. Install it
  358. The installer copies `skills/vault-generator/` into the directories each agent scans for skills:
  359. | Scope | Command | Claude Code location | Codex location |
  360. | --- | --- | --- | --- |
  361. | One project | `node skills/vault-generator/scripts/install.ts --target /path/to/project` | `<project>/.claude/skills/vault-generator/` | `<project>/.agents/skills/vault-generator/` |
  362. | All your projects | `node skills/vault-generator/scripts/install.ts --global` | `~/.claude/skills/vault-generator/` | `~/.agents/skills/vault-generator/` |
  363. Both agents are installed by default. Add `--agent claude` or `--agent codex` to install only one. On Windows,
  364. PowerShell and Command Prompt use the same commands, with Windows paths such as `--target C:\work\my-project`.
  365. Example output:
  366. ```text
  367. ✔ claude-code: installed /path/to/project/.claude/skills/vault-generator
  368. ✔ codex: installed /path/to/project/.agents/skills/vault-generator
  369. Invoke with /vault-generator in Claude Code and $vault-generator in Codex (restart the agent if the skill does not appear).
  370. ```
  371. **Project or global?** Install into a project when you want the whole team to get the skill: commit the
  372. `.claude/skills/` and `.agents/skills/` folders with the project. Install globally when you want it available in
  373. every repository on your machine, for yourself only.
  374. **Manual installation** also works, because the skill is a self-contained folder. Copy `skills/vault-generator/` to one
  375. of the locations above, keeping the folder name `vault-generator`.
  376. ### 4. Check that it works
  377. ```sh
  378. # the engine runs on its own (no agent needed)
  379. node /path/to/project/.claude/skills/vault-generator/scripts/vg.mjs --mode capabilities
  380. # the installed copy is a valid Agent Skill
  381. node /path/to/project/.claude/skills/vault-generator/scripts/vg.mjs --mode validate-skill \
  382. --skill-dir /path/to/project/.claude/skills/vault-generator
  383. ```
  384. `capabilities` must report `search index available (SQLite FTS5)`. If it does not, your Node.js is too old.
  385. Then open the project in your agent:
  386. | Agent | Check | Invoke |
  387. | --- | --- | --- |
  388. | Claude Code | Type `/` and look for `vault-generator` in the list | `/vault-generator` |
  389. | Codex | Run `/skills` and look for `vault-generator` | `$vault-generator` |
  390. Claude Code picks up new skills while it is running. If the skill does not show up, restart the agent; Codex also
  391. recommends a restart after installing a skill.
  392. ### Updating
  393. Pull the latest version and run the same install command again:
  394. ```sh
  395. git pull
  396. node skills/vault-generator/scripts/install.ts --target /path/to/project
  397. ```
  398. The installer is safe to repeat:
  399. - An identical copy is left alone (`up-to-date`).
  400. - A copy installed by an earlier version is replaced (`updated`).
  401. - A copy you edited by hand, or a different skill that is also called `vault-generator`, is **not** replaced. The
  402. installer stops and reports `refused`. Add `--force` to replace it; a backup is saved first in
  403. `.vault-generator-install-backups/` (in the project, or in your home directory with `--global`).
  404. - `--dry-run` shows what would happen without writing anything.
  405. Updating the skill never touches the vaults you have generated. Run `sync` afterwards if you want existing vaults to
  406. pick up improvements in the analyzers.
  407. ### Uninstalling
  408. ```sh
  409. node skills/vault-generator/scripts/install.ts --target /path/to/project --uninstall
  410. node skills/vault-generator/scripts/install.ts --global --uninstall
  411. ```
  412. Only copies created by the installer are removed; anything else needs `--force`. Generated vaults are not deleted.
  413. They are plain Markdown folders that you own.
  414. ### Troubleshooting
  415. | Problem | Fix |
  416. | --- | --- |
  417. | `vault-generator requires Node.js >= 22.18` | Upgrade Node.js (for example with `nvm install 22` or the installer from nodejs.org) |
  418. | The skill does not appear in the agent | Restart the agent, check that the folder is called exactly `vault-generator` and contains `SKILL.md`, and that you opened the project the skill was installed into |
  419. | `refused: installed copy was modified locally` | Your copy differs from the one being installed. Keep it, or re-run with `--force` (a backup is kept) |
  420. | The agent asks for permission every time it runs the engine | Expected the first time. Allow `node … vg.mjs` in your agent's permission settings if you trust it |
  421. | `search index UNAVAILABLE` in `capabilities` | Your Node.js build lacks `node:sqlite` with FTS5. Use an official Node.js 22.18+ build |
  422. | The skill does not appear after a plugin install | Run `/reload-plugins` or restart Claude Code, then check `claude plugin list` and the **Errors** tab of `/plugin` |
  423. | The one-step plugin install does not work | It needs Claude Code 2.1.292+ in a shell, or 2.1.275+ inside a session. Update Claude Code, or add the marketplace first and install in two steps |
  424. ## Example
  425. Take a small pnpm monorepo with a Next.js app, a Fastify API and three shared packages. The first run asks before
  426. writing anything:
  427. ```text
  428. $ vg --mode generate
  429. ? [generate] Input needed before writing anything (1 blocking question(s)).
  430. Questions (answer to continue):
  431. • [destination] (blocking) Where should the vault be created? Proposed: knowledge-vault
  432. why: Writing a new directory is a decision only you can make. Answer "default" to accept the proposal or give a path.
  433. ```
  434. After the answer it generates one note per project, a home note with the dependency graph, a technologies index and an
  435. *Open questions* note. This is the note for the shared API client, unedited:
  436. ````markdown
  437. ---
  438. title: "@shop/api-client"
  439. type: project
  440. version: 0.2.0
  441. tags: [kind/library, project/shop-api-client, tech/typescript, type/project]
  442. belongs_to: ["[[shop]]"]
  443. depends_on: ["[[shop-models]]"]
  444. used_by: ["[[shop-web]]"]
  445. symbols: [getProducts]
  446. vg:
  447. id: vg-5d5aaa84ae
  448. origin: generated
  449. confidence: verified
  450. sources: ["shop:packages/api-client/package.json@b63a1f77c3e8"]
  451. ---
  452. <!-- vg:begin -->
  453. # @shop/api-client
  454. **Kind:** library · **Ecosystem:** node · **Version:** `0.2.0` · **Path:** `packages/api-client`
  455. ## Purpose
  456. *No description is declared in the sources.*
  457. ## Workspace dependencies
  458. - [[shop-models]] — packages/api-client/package.json declares @shop/models (workspace:*) [prod]
  459. ## Public API
  460. #### getProducts · function
  461. ```ts
  462. async function getProducts(): Promise<Product[]>
  463. ```
  464. Fetch all products from the API.
  465. *Defined in* `packages/api-client/src/index.ts:4`
  466. ## Possible relations (unverified)
  467. > [!question] These relations were derived from patterns (names, URLs, routes). They are not stated by any source; confirm or reject them before relying on them.
  468. - [[shop-api-client]] **consumes** [[shop-api]] — literal "http://localhost:4000/products" matches route GET /products declared in apps/api/src/main.ts:5
  469. <!-- vg:end -->
  470. <!-- Add your own notes below this line. vault-generator never modifies content outside the vg:begin / vg:end block. -->
  471. ````
  472. (Frontmatter shortened for the README.) A few things to notice:
  473. - The missing description is stated, not invented.
  474. - The `depends_on` relation is verified, because a manifest declares it.
  475. - The client → API relation is only a pattern match, so it is listed as *possible* and the user is asked to confirm it.
  476. - Anything written below the last line is never touched by a later sync.
  477. An agent preparing to change this code asks for a context package instead of reading the repository:
  478. ```text
  479. $ vg --mode context "add a getProduct function to the api client" --budget 1200
  480. # Context package: add a getProduct function to the api client
  481. > 6 fragment(s) · ~330/1200 tokens. Every fragment cites its note and original source.
  482. ## Uncertainties
  483. - Some relations shown are inferred (unverified).
  484. ## Relevant knowledge
  485. ### @shop/api-client › Public API › getProducts · function
  486. *Note:* `shop-api-client.md` lines 64–79 · *confidence:* high
  487. *Sources:* `shop:packages/api-client/package.json@b63a1f77c3e8`
  488. ...
  489. ```
  490. ## How it works
  491. ```text
  492. sources ─► context detection ─► safe scan ─► analyzers ─► knowledge model ─► adaptive planner
  493. │
  494. search / context ◄── SQLite FTS5 index ◄── non-destructive reconciliation ◄┘
  495. ```
  496. 1. **Context detection** reads evidence: workspace files (npm, pnpm, Yarn, Nx, Turborepo, Lerna, Rush, Go
  497. workspaces, Cargo, Maven, Gradle, .NET solutions, uv, Deno, git submodules), manifests, git repositories,
  498. documentation trees and existing vaults. The result has a confidence score and a list of ambiguities.
  499. 2. **Scanning** honours `.gitignore`, skips dependency and build directories, never reads secret files, and flags
  500. documents that look private.
  501. 3. **Analyzers** extract documents (Markdown, MDX, HTML, generated doc sites, plain text, Mermaid), API contracts
  502. (OpenAPI 3 / Swagger 2), the public surface of the code (exported symbols, signatures, doc comments, HTTP
  503. routes, imports) and operational configuration (Docker, Compose, Kubernetes, CI workflows, Terraform, env
  504. templates, Makefiles).
  505. 4. **The knowledge model** joins all of this into projects, modules, documents, APIs, decisions and examples, linked
  506. by `belongs-to`, `depends-on`, `implements`, `exposes`, `consumes`, `documents`, `exemplifies`, `supersedes` and
  507. more. Each relation is `verified` (declared by a source), `inferred` (pattern match) or `confirmed` (by you). The
  508. model also detects contradictions between sources, such as different runtime versions or documented scripts that
  509. do not exist.
  510. 5. **The planner** decides the vault layout from what was found. It merges small projects into one note, splits
  511. oversized documents by heading and de-duplicates identical documents. Index notes are only created when they carry
  512. value.
  513. 6. **Reconciliation** writes the plan without destroying anything (see below), then **indexes** the vault in a local
  514. SQLite FTS5 database.
  515. The skill's `SKILL.md` is short. The agent loads the detailed procedures from `references/` only when a task needs
  516. them, following the Agent Skills progressive-disclosure model.
  517. ## What it guarantees
  518. - **Evidence only.** Notes state what the sources show and cite them. Unknowns are written as unknowns.
  519. - **Your content is yours.** Generated content lives between `<!-- vg:begin -->` and `<!-- vg:end -->`. Text outside
  520. that block is never modified. Edits inside it are merged with new source content (three-way merge) or recorded as a
  521. conflict with both versions kept. Properties you add to a note survive syncs.
  522. - **Stable identity.** Every note has a stable `vg.id`. Renaming or moving a note, or renaming a source file whose
  523. content did not change, keeps its identity and its links.
  524. - **Nothing is deleted.** Notes whose source disappeared are marked stale, not removed. Every run that changes files
  525. stores backups and a journal, and `restore` undoes it.
  526. - **Idempotent and reproducible.** Running again with no changes writes nothing. The same sources and configuration
  527. produce the same notes.
  528. - **Asks before deciding for you.** Blocking questions stop a run before anything is written. Answers are stored in
  529. the manifest and not asked again.
  530. ## Security and privacy
  531. The scripts enforce these rules for their own reads and writes. They are code paths covered by tests, not
  532. conventions:
  533. - Writes only go to authorised directories (the vault and the output paths you name), never into `.git/` or
  534. `node_modules/`.
  535. - Path traversal is rejected, and symbolic links are followed only when they stay inside the source.
  536. - Secret files (`.env`, private keys, credentials, cloud configs, Terraform state) are never read. Secret-looking
  537. values in other files (tokens, keys, passwords, credentials in URLs) are redacted before they reach a note, the
  538. index or an export. `validate` fails if one slips through.
  539. - Documents that look private need an explicit decision. Restricted notes are hidden from search, context and
  540. exports unless you ask for them.
  541. - Text inside documents is treated as data. Content that looks like instructions to an AI agent is flagged in the
  542. vault, and the skill tells the agent never to follow it.
  543. - The manifest and state store relative paths only, never absolute paths or file contents. Plugins run only after you
  544. explicitly trust them.
  545. - Everything runs locally. The engine makes no network requests. The only exceptions are explicit opt-ins:
  546. `examples --validate` runs `npm install` / `npm start` for a generated example, and an exported HTML site loads
  547. Mermaid from a CDN in the reader's browser to draw diagrams.
  548. The skill cannot restrict the other tools your agent has. Configure your agent's own permissions as well (Claude Code
  549. `permissions.deny`, Codex `sandbox_mode` / `approval_policy`). See
  550. [references/security.md](skills/vault-generator/references/security.md).
  551. ## Supported sources
  552. | Kind | Supported |
  553. | --- | --- |
  554. | Documentation | Markdown, MDX (components become placeholders), HTML, plain text, Mermaid. reStructuredText and AsciiDoc are imported as text |
  555. | Generated docs | TypeDoc, Compodoc, Javadoc, Sphinx, MkDocs and Docusaurus builds (navigation chrome removed) |
  556. | API contracts | OpenAPI 3.x and Swagger 2.0 in JSON or YAML, with contract-change detection |
  557. | Code (public surface) | TypeScript/JavaScript (incl. JSX, Vue, Svelte, Astro), Python, Go, Java, Kotlin, Scala, C#, Rust, Swift, PHP, Dart, C/C++ |
  558. | Ecosystems | Node.js, Python, Go, Rust, JVM (Maven/Gradle), .NET, PHP, Ruby, Dart/Flutter, Elixir, Deno |
  559. | Configuration | Dockerfile, Docker Compose, Kubernetes, GitHub Actions, GitLab CI, Terraform, Helm, env templates, Makefile/justfile, runtime version files |
  560. | Vaults | Existing Obsidian vaults, with or without notes created by this tool |
  561. Run `vg --mode capabilities` to see exactly what your installation supports, including what is not implemented.
  562. ## Reference
  563. Detailed documentation lives with the skill and is what the agent reads:
  564. | Document | Contents |
  565. | --- | --- |
  566. | [SKILL.md](skills/vault-generator/SKILL.md) | The instructions agents follow: activation, operation selection, questions, security |
  567. | [operations.md](skills/vault-generator/references/operations.md) | Every mode and option of the CLI, exit codes, configuration keys |
  568. | [questions.md](skills/vault-generator/references/questions.md) | Every question the skill can ask, when, and what each answer does |
  569. | [vault-format.md](skills/vault-generator/references/vault-format.md) | Note anatomy, identifiers, links, layout rules, the `.vault-generator/` directory |
  570. | [sync-and-conflicts.md](skills/vault-generator/references/sync-and-conflicts.md) | Change detection, merge rules, conflict resolution, recovery |
  571. | [retrieval.md](skills/vault-generator/references/retrieval.md) | The index, search ranking and context packages |
  572. | [security.md](skills/vault-generator/references/security.md) | Enforced controls and what you must configure in your agent |
  573. | [examples.md](skills/vault-generator/references/examples.md) | How grounded examples and demo apps are produced and validated |
  574. | [extending.md](skills/vault-generator/references/extending.md) | Writing analyzer and transformer plugins |
  575. ## Configuration
  576. Configuration is optional. Add `vault-generator.config.json` at the root of a project to set defaults:
  577. ```json
  578. {
  579. "sources": ["."],
  580. "vault": "knowledge-vault",
  581. "language": "en",
  582. "depth": "standard",
  583. "exclude": ["**/fixtures/**", "legacy/**"],
  584. "access": { "deny": ["secrets/**"], "restricted": ["docs/internal/**"] },
  585. "plugins": []
  586. }
  587. ```
  588. The main keys are the default sources, vault and scope; the language of generated notes (`en` or `es`, detected
  589. automatically otherwise); the code detail level (`shallow`, `standard` or `deep`); include and exclude rules; and access
  590. rules. A complete example with every key is in
  591. [assets/vault-generator.config.example.json](skills/vault-generator/assets/vault-generator.config.example.json), and
  592. each key is described in [operations.md](skills/vault-generator/references/operations.md#configuration-file). No
  593. environment variables are used.
  594. ## Extending
  595. New formats and output types are added as local plugins without changing the core:
  596. ```js
  597. // vault-plugins/asciidoc.mjs — listed in "plugins" in the config
  598. export default {
  599. analyzers: [{
  600. id: 'asciidoc', version: '1', description: 'AsciiDoc documents', handles: ['.adoc'],
  601. limitations: ['Tables and includes are not converted'],
  602. match: (file) => (file.ext === '.adoc' ? 30 : 0),
  603. analyze(file, ctx) { /* return documents, entities, relations and facts */ },
  604. }],
  605. transformers: [],
  606. };
  607. ```
  608. Every analyzer and transformer declares what it handles and what it cannot preserve, and `capabilities` reports both.
  609. Plugins are loaded only after you review them and run once with `--trust-plugins`. Their content hash is pinned, so a
  610. modified plugin has to be trusted again. See [extending.md](skills/vault-generator/references/extending.md) for the
  611. full contract.
  612. ## Limitations
  613. - **PDF, Word and PowerPoint files are not converted.** They are listed as unsupported in the vault, never silently
  614. dropped.
  615. - **Retrieval is lexical** (BM25 ranking, symbol and operation matching, relation expansion). There are no embeddings
  616. or semantic search.
  617. - **Code analysis is heuristic, not a compiler.** Complex generics, macros, overloads and re-export chains may be
  618. summarised or missed. Runtime behaviour is never inferred.
  619. - **Relations between applications** that do not share a declared contract are only detected by pattern matching
  620. (for example a URL in one project matching a route in another). They stay "possible" until you confirm them.
  621. - **External OpenAPI `$ref` files and remote sources** are not fetched.
  622. - **Example scaffolding** supports Node.js and Python projects only.
  623. - **Tested on** Node.js 24 on Windows with the automated suite. End-to-end invocation from inside Claude Code and
  624. Codex has not yet been covered by automated tests.
  625. ## Roadmap
  626. - Optional PDF and DOCX extractors as plugins with declared dependencies.
  627. - Optional local embeddings for hybrid search.
  628. - Compiler-backed analyzers (TypeScript compiler API, Roslyn, `go/ast`) as plugins.
  629. - Service relations from generated clients, message queues and event schemas.
  630. - Example scaffolding for Go, JVM and .NET.
  631. - Batched synchronisation for very large vaults.
  632. ## Development
  633. ```text
  634. skills/vault-generator/ the skill (this is what gets installed)
  635. ├── SKILL.md agent instructions
  636. ├── agents/openai.yaml Codex interface metadata
  637. ├── references/ on-demand documentation
  638. ├── assets/ example configuration
  639. └── scripts/
  640. ├── vg.mjs CLI entry point
  641. ├── install.ts installer
  642. ├── vendor/ bundled parsers (yaml, smol-toml) and their licences
  643. └── lib/ the engine (detection, analyzers, model, planner, reconciliation, index, …)
  644. tests/ unit tests and the scenario suite (isolated temporary fixtures)
  645. tools/build-vendor.mjs rebuilds the bundled parsers
  646. tools/version.mjs keeps the version in sync across files and checks it
  647. .claude-plugin/marketplace.json Claude Code plugin marketplace (points at skills/vault-generator)
  648. .github/workflows/ CI (ci.yml) and release (release.yml)
  649. ```
  650. `.claude/skills/vault-generator/` and `.agents/skills/vault-generator/` are installed copies, so the skill can be tried
  651. in this repository itself. Re-run the installer after changing `skills/vault-generator/`.
  652. ```sh
  653. npm install # development tools only (TypeScript, esbuild, parser sources)
  654. npm test # 51 tests: unit tests plus 28 end-to-end scenarios
  655. npm run typecheck
  656. npm run validate-skill # checks SKILL.md against the Agent Skills specification
  657. claude plugin validate . --strict # checks the plugin marketplace (needs Claude Code)
  658. npm run version:check # the version is the same everywhere and the installed copies match the skill
  659. npm run vendor # rebuild the bundled parsers after upgrading them
  660. ```
  661. The engine is TypeScript that Node runs directly (type stripping). There is no build step and no runtime
  662. `node_modules`.
  663. ### Releases
  664. CI (`.github/workflows/ci.yml`) runs on every push to `master` and on every pull request. It runs the type check, the
  665. test suite and `validate-skill` on Ubuntu and Windows with Node.js 22.18 and 24. It also runs
  666. `claude plugin validate . --strict`, and checks that the version is the same in every file and that the installed copies
  667. match the skill.
  668. To publish a release, open the **Actions** tab on GitHub, choose **Release** in the list on the left and click
  669. **Run workflow**. Then choose:
  670. - **Use workflow from**: the branch to release from. The default branch is preselected.
  671. - **bump**: `patch`, `minor` or `major`.
  672. - **beta**: tick it to publish a beta (a pre-release) instead of a stable release.
  673. From version `0.1.0`: `patch` gives `0.1.1`, `minor` gives `0.2.0` and `major` gives `1.0.0`. With **beta** ticked,
  674. `minor` gives `0.2.0-beta.1`, and running it again gives `0.2.0-beta.2`. Running `minor` without **beta** after that
  675. publishes `0.2.0`.
  676. The workflow rewrites every file that carries the version (`npm run version:set`), runs the type check, the tests and
  677. `validate-skill` on the result, and only then commits the change and the tag `vX.Y.Z` to the chosen branch in one atomic
  678. push. It then creates a GitHub release with generated notes and two assets: `vault-generator-skill-vX.Y.Z.zip` (the
  679. skill folder, ready to unzip into `.claude/skills` or `.agents/skills`) and `SHA256SUMS`. If a check fails, nothing is
  680. pushed.
  681. The workflow has to be started from the Actions tab: the Releases page only lists releases. It pushes to the chosen
  682. branch, so it fails if that branch requires pull requests.
  683. The plugin marketplace has no `version` field, so `claude plugin install` always installs the latest commit of the
  684. default branch. The zip is how to pin a release.
  685. ## Contributing
  686. Issues and pull requests are welcome. Before opening a pull request:
  687. 1. Keep the output deterministic (stable ordering, no timestamps in notes). Reproducibility is a tested guarantee.
  688. 2. Add or update a fixture and a test for the behaviour you change (`tests/fixtures.ts`, `tests/scenarios/`).
  689. 3. Run `npm test`, `npm run typecheck` and `npm run validate-skill`.
  690. 4. If you add an analyzer or transformer, declare its limitations honestly. Do not register capabilities that are not
  691. implemented.
  692. 5. Never commit real credentials. The test fixtures build their fake secrets at runtime so that secret scanners do not
  693. flag the repository.
  694. Contributions are accepted under the Apache License 2.0 (section 5 of the license).
  695. ## License
  696. Licensed under the [Apache License, Version 2.0](LICENSE). See [NOTICE](NOTICE) for attributions.
  697. The skill bundles [yaml](https://github.com/eemeli/yaml) (ISC) and [smol-toml](https://github.com/squirrelchat/smol-toml)
  698. (BSD-3-Clause) in `skills/vault-generator/scripts/vendor/`, with their licence texts. The installed skill carries its
  699. own `LICENSE.txt` and `NOTICE.txt`.
  700. Obsidian is a trademark of Dynalist Inc. Claude Code is a product of Anthropic and Codex a product of OpenAI.
  701. `vault-generator` is an independent project and is not affiliated with or endorsed by any of them.

Ratings and comments

Sign in to rate this skill.

Sign in

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