Generated banner for LLM Wiki Manager
Generated logo for LLM Wiki Manager

LLM Wiki Manager

LLM wiki kit

Created by sametbrr

Published in sametbrr/llm-wiki-manager. Publisher page

73 GitHub stars

What it is

Agent Skills plugin for a persistent LLM-managed markdown wiki — ingest, cross-reference, cited queries and lint with 5 stdlib scripts
— the description by sametbrr

AutoGineer overview, from the brain’s own files

LLM Wiki Manager is an agent skill and plugin designed to implement the Karpathy LLM Wiki pattern. It shifts the paradigm from traditional RAG—where an LLM re-reads raw documents on every query—to a persistent, compounding knowledge base. The system maintains a clear division of labor: the user curates raw source files in a dedicated folder, while the agent manages the wiki layer, handling synthesis, cross-referencing, indexing, and bookkeeping. It includes idempotent Python scripts for maintenance tasks like linting, logging, and schema evolution, ensuring that knowledge remains structured and traceable over time.

How it works

Memory model: LLM wiki

AutoGineer overview, from the brain’s own files

The system organizes data into a three-layer model: a schema file for conventions, a raw folder for immutable source documents, and a wiki folder for synthesized content. The agent uses a set of Python scripts to manage this structure. When a user provides a source, the agent ingests it, summarizes the content, updates entity and concept pages, and logs the action. It supports advanced operations like semantic updates to propagate changes across multiple pages, automated health checks that generate dated reports, and multi-wiki routing to bridge project-specific and global knowledge bases.

Folders
FolderRoleFiles
.githubagent-config2
skillsagent-instructions27
teststests1
.claude-pluginfolder1
.codex-pluginfolder1

The agent reads

The agent writes

Requirements

Works with: Claude Code, OpenAI Codex, GitHub Copilot, Cursor, Kiro, OpenCode, Amp, Cline, JetBrains Junie, Devin (ex-Windsurf)

Set it up

  1. Download the brain as a ZIP and unzip it where you keep your notes or project: https://mp-staging.autogineer.com/agent-brains/sametbrr/llm-wiki-manager/download
  2. Claude Code reads CLAUDE.md from this folder automatically.

  3. cd llm-wiki-manager && claude

  4. AutoGineer scanned these files at commit 28ad285.

  5. Created by sametbrr. Published in sametbrr/llm-wiki-manager. Licence: MIT License.

Usage

AutoGineer overview, from the brain’s own files

  • Bootstrap a new wiki environment in a research folder.
  • Ingest PDF or text documents into the wiki.
  • Query the wiki for synthesized answers with citations.
  • Perform semantic updates to propagate information changes across the wiki.
  • Run automated health checks to identify broken links or orphan pages.
  • Route knowledge between project-specific and global wikis.
“Set up an LLM wiki here. Topic: history of nutrition science.”
The agent scaffolds the raw/ and wiki/ folders and initializes the schema file.
“Add this PDF to the wiki.”
The agent reads the source, writes a summary, updates relevant entity pages, and logs the ingestion.
“Smith 2024 supersedes Keys 1980, update the wiki.”
The agent performs a semantic sweep across all pages to update the superseded claim and logs the change.
“Lint the wiki.”
The agent runs a health check, generates a dated report in the reports folder, and updates the index.

Documentation by sametbrr

Image: Release Image: License: MIT Image: Agent Skills

Quick Start • Installation • Usage • Update mode • Multi-wiki • Compatibility

LLM Wiki Manager

An Agent Skill and plugin for Claude Code and Codex for building and maintaining a personal LLM-managed wiki — a persistent, compounding knowledge base where the LLM does all the writing, cross-referencing, and bookkeeping while you curate sources and ask questions.

🇹🇷 Türkçe için README.tr.md


Quick Start

claude plugin marketplace add sametbrr/skill-hub && claude plugin install llm-wiki-manager@skill-hub   # Claude Code
codex plugin marketplace add sametbrr/skill-hub && codex plugin add llm-wiki-manager@skill-hub         # Codex

Start a new session in your research folder:

mkdir ~/research/my-topic && cd ~/research/my-topic && claude   # or: codex
> "Set up an LLM wiki here. Topic: history of nutrition science."

Features

Instead of RAG — where the LLM rediscovers answers from raw documents on every query — this pattern has the LLM compile raw sources into a persistent, interlinked markdown wiki. Each new source enriches existing pages. Cross-references are built eagerly. Contradictions are flagged. Knowledge compounds over time.

Implements Karpathy's LLM Wiki pattern as a full agent skill with 9 operating modes (including multi-wiki routing and migrate), 5 idempotent Python scripts, 8 page templates, and 11 reference documents.

Without this pattern          With this pattern
────────────────────          ──────────────────
Query 1 → re-read 50 docs     Query 1 → read compiled wiki (already synthesized)
Query 2 → re-read 50 docs     Query 2 → read updated wiki (cross-refs already there)
Query 3 → re-read 50 docs     Query 3 → read updated wiki (contradictions already flagged)

Requirements

  • Claude Code, OpenAI Codex, or any agentskills.io-compatible agent

  • Python 3.9+ (stdlib only, for the 5 included scripts — no pip install needed)


Installation

Option 1 — Claude Code plugin (recommended)

claude plugin marketplace add sametbrr/skill-hub
claude plugin install llm-wiki-manager@skill-hub

Option 2 — Codex plugin

codex plugin marketplace add sametbrr/skill-hub
codex plugin add llm-wiki-manager@skill-hub

Option 3 — GitHub CLI, any agent (gh CLI with gh skill)

gh skill install sametbrr/llm-wiki-manager llm-wiki-manager --agent claude-code --scope user   # or --agent codex

Option 4 — manual copy: copy skills/llm-wiki-manager/ into ~/.claude/skills/ or ~/.agents/skills/.

After installing, start a new session. The skill loads automatically when relevant.


Usage

The skill auto-detects which mode applies from natural language. No slash commands needed.

> "Set up an LLM wiki here"                             # Bootstrap: scaffold raw/, wiki/ and the schema file
> "Add this PDF to the wiki"                            # Ingest: summarize, cross-reference, index, log
> "What does the wiki say about X?"                     # Query: answer with citations, offer to file back
> "Smith 2024 supersedes Keys 1980, update the wiki"    # Update: sweep every page that paraphrases the claim
> "Lint the wiki"                                       # Lint: dated health report in wiki/reports/
> "We should always do X going forward"                 # Schema-evolve: record a convention for future sessions
> "Add this to my global wiki"                          # Multi-wiki: route between project and global wiki
> "How does this pattern work?"                         # Teach: explain the pattern and compare it with RAG
Modes
ModeTrigger examplesWhat happens
Bootstrap"Set up a wiki", "start a knowledge base here"Scaffolds raw/, wiki/ and the schema file (AGENTS.md + a CLAUDE.md pointer) from templates
Ingest"Add this PDF to the wiki", "I just read X, file it"Reads source → writes summary → updates entity/concept pages → indexes → logs
Query"What does the wiki say about X?", "Compare X and Y"Reads index → candidate pages → synthesizes answer with citations → offers to file back
Update"Smith 2024 supersedes Keys 1980, update the wiki"Semantic sweep across all pages → diff-before-write per page → single log entry
Lint"Health check the wiki", "anything broken?"Runs lint_wiki.py → auto-saves wiki/reports/lint-YYYY-MM-DD.md → auto-tracks in index and log
Schema-evolve"We should always do X going forward"Updates the schema file (AGENTS.md / CLAUDE.md) so future sessions inherit the convention
Multi-wiki"Add this to my global wiki", "promote this page to global"Routes between project wiki and global wiki using the External Wiki: declaration in project CLAUDE.md
Teach"How does this pattern work?", "explain the LLM wiki idea"Explains the pattern, compares with RAG, walks through a concrete example
Full walkthrough
# 1. Go to your research folder
mkdir ~/research/my-topic && cd ~/research/my-topic && claude

# 2. Bootstrap the wiki
> "Set up an LLM wiki here. Topic: history of nutrition science."

# 3. Drop a source
cp ~/Downloads/pollan-2008.pdf raw/

# 4. Ingest it
> "Ingest Pollan's In Defense of Food"

# 5. Ask questions
> "What does the wiki say about nutritionism?"

# 6. Health check (auto-saves dated report to wiki/reports/)
> "Lint the wiki"

The three-layer model

your-wiki/
├── AGENTS.md          # Schema — conventions for this wiki (co-evolved over time)
├── CLAUDE.md          # One line: @AGENTS.md (Claude Code reads CLAUDE.md, Codex reads AGENTS.md)
├── raw/               # YOUR layer — immutable sources you curate. LLM reads, never writes.
└── wiki/              # LLM layer — all pages written and maintained by the LLM
    ├── index.md       # Content catalog (updated on every ingest)
    ├── log.md         # Append-only operation log (greppable)
    ├── hot.md         # Hot cache — most recently ingested sources and active references
    ├── sources/       # One summary page per ingested source
    ├── entities/      # People, organizations, places, products
    ├── concepts/      # Ideas, theories, frameworks, terms
    ├── notes/         # Filed-back query answers and loose pages
    └── reports/       # Auto-generated dated lint reports (wiki/reports/lint-YYYY-MM-DD.md)

Division of labor:

You doThe LLM does
Curate sources (decide what to read)Read sources end-to-end
Ask questions, steer directionWrite summaries, entity and concept pages
Review the wiki, follow linksUpdate cross-references in-place
Decide what mattersMaintain index.md and log.md
Own raw/Flag contradictions, surface gaps

You almost never write wiki pages by hand. The LLM does the bookkeeping — that's what makes the wiki compound instead of collapse.


Core disciplines

  1. LLM owns wiki/. You own raw/. No exceptions.

  2. Every operation logs to log.md via append_log.py. Greppable: grep "^## \[" log.md | tail -20

  3. Every new or updated page touches index.md via update_index.py. Stale index = wiki that feels lost.

  4. Cross-reference aggressively. When a source mentions an entity that already has a page, update that page. Don't leave connections implicit.

  5. Cite back to raw/. Every claim is traceable to a specific source file.

  6. Flag contradictions, don't overwrite. New source disagrees with old claim? Both stay, marked with their source, with a > [!warning] Sources disagree callout.

  7. Schema lives in CLAUDE.md. When a convention works, write it down. The next session starts informed.


What's inside

Scripts (Python stdlib, no dependencies, all idempotent)
ScriptPurpose
scripts/init_wiki.pyScaffold a new wiki — creates raw/, wiki/, the schema file (AGENTS.md + CLAUDE.md pointer, or keeps an existing one), index.md, log.md, and hot.md. Idempotent.
scripts/append_log.pyAppend a ## [YYYY-MM-DD] action | title entry to log.md. Supports flexible log path detection.
scripts/update_index.pyAdd or update an entry under a category in index.md. Case-insensitive categories, keeps section order and content, follows the index link style (markdown or [[wikilinks]]), new categories go before ## Meta.
scripts/lint_wiki.pyHealth check. Detects orphan pages, broken links and index drift in both standard markdown and Obsidian wiki-link format ([[page#heading]], ![[embed.png]] included). Default: writes wiki/reports/lint-<today>.md and auto-tracks. Run --stdout for terminal output.
scripts/migrate_wiki.pySchema upgrade (v1 → v2). Deduplicates index.md, moves dated changelog blocks from hot.md into log.md, stamps the schema version. Idempotent.
Templates
TemplateUsed for
wiki-CLAUDE.md.tmplThe schema file dropped into a fresh wiki
source-summary.md.tmplOne ingested source — claims, methodology, cross-links, open questions
entity-page.md.tmplPeople, organizations, places, products
concept-page.md.tmplIdeas, frameworks, theories, terms
comparison-page.md.tmpl"X vs Y" pages, often filed-back query answers
index.md.tmplInitial content catalog
log.md.tmplInitial log with bootstrap entry
hot.md.tmplInitial hot cache — rewritten after each ingest with latest sources and active references
Reference docs

Eleven detailed workflow documents in references/: philosophy.md · architecture.md · bootstrap-workflow.md · ingest-workflow.md · query-workflow.md · update-workflow.md · lint-workflow.md · migrate-workflow.md · schema-design-guide.md · multi-wiki-routing.md · teaching-mode.md

The skill reads these selectively — you don't need to. They're there to give the LLM depth on each mode.


Update mode

Standard ingest already handles contradictions on a single page (Disputes section). Update mode is for when a new source supersedes a claim that's paraphrased across multiple pages — the same idea written four different ways in four different files.

Scenario: Smith 2024 reanalysis shows Keys 1980's seven-countries study cherry-picked data.
The Keys r=0.87 claim appears as:
  concepts/saturated-fat.md     → "Keys found r=0.87 across seven countries"
  entities/ancel-keys.md        → "famous for showing strong correlation"
  concepts/heart-disease.md     → "saturated fat is a primary driver per Keys"
  concepts/dietary-policy.md    → "the saturated fat hypothesis drove decades of policy"

Update mode:
  1. Semantic sweep — finds all four (grep won't, LLM will)
  2. Shows scope: "4 pages affected. Proceed?"
  3. Diff-before-write per page — y/n/skip/edit per change
  4. Per-page strategy: revise / disputes / annotate (not one-size-fits-all)
  5. One log entry tying all four edits to Smith 2024

This is change propagation, not change tracking. The log and frontmatter track what was edited. Update mode ensures the edit reaches everywhere it should.


Auto-dated lint reports

lint_wiki.py with no flags:

  • Writes wiki/reports/lint-YYYY-MM-DD.md (overwrites same-day run — idempotent daily)

  • Adds a Reports index entry automatically

  • Appends a lint | Health check log entry automatically

  • Exits with code 1 if any block-severity issue found (useful for CI)

Reports accumulate as a longitudinal health record. git log wiki/reports/ shows how wiki quality evolved over time.

Override flags: --stdout (terminal, no tracking), --no-track (write file, skip index/log), --report PATH (custom path).


Multi-wiki

Most users start with one wiki. Once you have two — say, a per-project wiki at the working directory plus a long-lived global "second brain" (often an existing Obsidian vault) — the skill routes writes between them based on a single declaration in the project's CLAUDE.md.

~/projects/x-project/          ← active project (current working directory)
├── CLAUDE.md                  ← project schema — declares the global wiki path
├── raw/                       ← project sources
└── wiki/                      ← project wiki

~/Documents/obsidian/          ← global wiki (long-lived, exists across projects)
├── CLAUDE.md                  ← global schema
├── raw/
└── wiki/
One-time setup

Add this to the project's CLAUDE.md (or ask the agent to do it):

## External Wiki

Global knowledge base: ~/Documents/obsidian/

### Routing rules
- Project-specific code decisions, architecture, bugs, configuration → this project's `wiki/`
- Concepts, frameworks, patterns, ideas applicable beyond this project → global wiki
- When in doubt, ask before writing
- Scripts always need `--path` flag pointing to the right wiki root

### Cross-wiki links
- Use absolute paths (`~/...`) when linking from one wiki to the other.
- Never use relative paths that cross wiki boundaries.
Four canonical scenarios
#ScenarioTriggerWhat the agent does
AWrite to global while in a project"Add JWT refresh rotation to my global wiki"Reads project CLAUDE.md → resolves global path → writes to global, project wiki untouched
BPull from global into a project"What does the global wiki say about rate limiting? Apply it to /api/search"Reads global pages → synthesizes recommendation → writes a project-specific page that links to the global one (never copies)
CPromote a page from project to global"concepts/event-sourcing.md has matured, promote it"Moves content to global → leaves a one-line redirect stub at the project path → updates both indexes and logs
DLint both wikis at once"Lint both wikis"Runs lint_wiki.py --path against each → reads both reports → returns one summary

Full walkthroughs of all four scenarios in references/multi-wiki-routing.md.


Compatibility

ToolInstallSchema file it reads
Claude Codeplugin (claude plugin install llm-wiki-manager@skill-hub) or ~/.claude/skills/CLAUDE.md
OpenAI Codexplugin (codex plugin add llm-wiki-manager@skill-hub) or ~/.agents/skills/AGENTS.md
GitHub Copilot, Cursor, Gemini CLI, …gh skill install … --agent <name>usually AGENTS.md

A wiki that keeps its schema in AGENTS.md with a one-line CLAUDE.md (@AGENTS.md) works in all of them; init_wiki.py sets that up.



Contributing


License

MIT — see LICENSE.


<div align="center">

Report Bug · Request Feature

</div>

skills/llm-wiki-manager/references/update-workflow.md

Update Workflow

Use this when a new source genuinely invalidates an existing claim across the wiki — not just contradicts it on one page (that's the standard ingest workflow's "Disputes" handling), but supersedes it broadly enough that multiple existing pages are now wrong or misleading.

This mode is the difference between change tracking (the wiki recording what was edited) and change propagation (the wiki staying internally consistent as new evidence arrives). The bookkeeping disciplines from ingest — log entries, frontmatter updated, git history — handle change tracking. They do not handle propagation. A new source can update one page via ingest, while three other pages quietly retain the now-stale claim. Update mode exists to sweep those.

When to invoke this mode (vs. ingest-with-Disputes)

The default is still ingest's Disputes handling: when a new source contradicts an existing claim on one page, add both with citations and flag the conflict. That's enough when the conflict is local.

Switch to update mode when any of these hold:

  • The user explicitly says "update the wiki for new info — X is no longer right" or "Smith 2024 supersedes Keys 1980, please correct everywhere".

  • During ingest, you find the new source's central claim contradicts material on 3 or more existing pages (not just the page being directly created/updated).

  • A lint pass surfaces an unflagged contradiction that turns out to span multiple pages.

  • The user is explicitly correcting a factual error they noticed while reading the wiki.

If you're unsure whether the conflict is "local" or "broad", default to update mode — its diff-before-write discipline is safe to invoke, and the worst case is you confirm only one page needs changing and proceed.

Why a dedicated mode

Three failure modes the ingest workflow alone can't catch:

  1. The new source doesn't mention the entity directly. Smith 2024 critiques the seven-countries methodology without naming Ancel Keys. Ingest will create sources/smith-2024.md and update concepts/saturated-fat.md. It will not touch entities/ancel-keys.md because Smith never said "Keys" — but that page now contains a stale framing.

  2. The same claim is paraphrased differently across pages. "r=0.87 across seven countries" / "strong correlation" / "primary driver" / "drove decades of policy" — same idea, four wordings, four pages. Grep won't find them all; semantic search will.

  3. Silent overwriting destroys the audit trail. Just editing each page leaves no record of why it changed. Update mode emits a single coherent log entry that ties the four edits to the new source.

The full loop

1. Identify the claim being superseded

State it in one sentence, in the language the wiki was written in:

"The seven-countries study established that saturated fat consumption strongly correlates with heart disease."

This is the claim under review. Everything that follows refers to it.

2. Identify the source authorizing the change

Update mode is only invoked when there's a specific source that justifies the change — either a newly-ingested one, or one already in the wiki that wasn't fully integrated when it arrived. State the source-summary page that grounds the update:

Authority: wiki/sources/smith-2024-seven-countries-reanalysis.md

If no such source-summary page exists yet, ingest first, then come back to update mode. Never run update mode from general LLM knowledge alone. The wiki's claim-to-source traceability is the entire reason it's trustworthy.

3. Sweep — find every page that asserts (or implies) the claim

Read wiki/index.md. Pick candidate categories: usually concepts/, often entities/, sometimes notes/. Read each candidate page that's plausibly related, and collect occurrences:

[
  ("concepts/saturated-fat.md", 22-25, "Keys (1980) found that saturated fat..."),
  ("entities/ancel-keys.md", 14-16, "famous for showing strong correlation..."),
  ("concepts/heart-disease-causes.md", 33, "saturated fat is a primary driver per Keys"),
  ("concepts/dietary-policy.md", 47, "the saturated fat hypothesis drove decades..."),
]

Don't grep — it misses paraphrases. Read pages and judge semantically. Be conservative: a sentence that mentions Keys without asserting the disputed claim is not a hit. A sentence that asserts the claim, with or without naming Keys, is a hit.

If the candidate set is empty, the claim was either never widely propagated or you've over-narrowed the candidate categories. Re-check.

4. Show the user the proposed scope

Before writing anything, present the sweep result:

Found 4 pages affected. Proposed action: update each in light of sources/smith-2024-seven-countries-reanalysis.md. Want to proceed? I'll show diffs for each one and confirm individually.

This is the most important checkpoint in the workflow. A 4-page update is cheap to confirm, expensive to undo. Wait for explicit go-ahead.

5. Diff-before-write, page by page

For each hit, show a unified diff before writing:

# concepts/saturated-fat.md, lines 22-25
- Keys (1980) found that saturated fat consumption strongly correlates
- with heart disease incidence (r=0.87 across seven countries).
- This finding shaped USDA dietary guidance for four decades.
+ Keys (1980) initially reported a strong correlation (r=0.87) across
+ seven cherry-picked countries; subsequent reanalysis with the full
+ 22-country dataset shows weak correlation
+ (see [Smith 2024](../sources/smith-2024-seven-countries-reanalysis.md)).
+ This earlier finding nonetheless shaped USDA guidance for four decades.

Ask y/n/skip/edit per page, or offer all after the first one if the user wants to batch-confirm. Apply each approved diff immediately; don't wait until the end (if something fails halfway, the wiki should be in a coherent partial state, not a corrupt one).

6. Decide between revision and Disputes

For each hit, the right action is one of:

  • Revise — replace the stale claim with the corrected one, citing the new source. Right when the new source clearly settles the question.

  • Disputes — keep both claims side-by-side under a > [!warning] Sources disagree callout. Right when both sides have non-trivial evidence and the wiki should record the disagreement rather than pick a winner.

  • Annotate — keep the original claim with a parenthetical note: "(this 1980 framing was later contested; see Smith 2024)". Right when the historical claim is itself a fact (e.g. that USDA based policy on Keys is true regardless of whether Keys was right).

The user makes this call per page. Don't default to one strategy across all four — each page may warrant a different choice.

7. Update the index for any pages whose summary changed

If a page's index summary now misrepresents the page (e.g., entry says "primary driver of heart disease" when the page now says "contested"), run update_index.py for it. Most updates won't change the index summary, but check.

8. One log entry summarizing the whole sweep
python scripts/append_log.py --action update \
  --title "Saturated fat / Keys 1980 correction" \
  --details "Smith 2024 reanalysis. Revised: concepts/saturated-fat.md, entities/ancel-keys.md, concepts/heart-disease-causes.md. Annotated: concepts/dietary-policy.md. 4 pages touched."

The log entry ties all the edits to one source-driven event. This is the audit trail. Six months from now, if someone asks "when did we update the Keys framing?", grep "update | Saturated fat" log.md is the answer.

Optional: pre-update git commit

Strongly recommended for non-trivial sweeps. Before applying any diffs:

git add -A && git commit -m "Pre-update snapshot before Keys correction"

This gives you a single rollback point. Update mode does not enforce git, but the workflow is materially safer with it. Mention this once when the user invokes update mode for the first time in a wiki that's a git repo; subsequently, just do it silently as part of step 5.

Heuristics

  • Don't run update mode from general knowledge. The trigger is always "a specific source supersedes a specific claim". If the user invokes it without a source, ingest the source first.

  • Confirm scope before writing. Step 4 is non-negotiable. A silent multi-page edit erodes trust faster than any other failure mode in the wiki.

  • Diffs over prose summaries. "I'll change line 23 to say X" is worse than showing the unified diff. The diff is unambiguous; the prose hides what's actually being changed.

  • Per-page choice between revise/dispute/annotate. Don't apply one strategy uniformly. The right action depends on the nature of each page.

  • One log entry, not four. The sweep is one logical event. Logging four entries fragments the audit trail and makes future grep less useful.

  • Don't over-sweep. A passing mention of "Keys 1980" inside a long paragraph is not necessarily a hit — only flag pages that assert the disputed claim.

Common mistakes

  • Running update mode for local conflicts. If only one page is affected, ingest's Disputes handling is correct. Update mode is for multi-page propagation; using it for single-page edits is overkill and dilutes the mode's signal.

  • Skipping the source check (step 2). "I just remember that Keys was wrong" is not a basis for a sweep. The wiki is grounded in cited sources or it's nothing.

  • Silent edits. No diffs shown, no log entry, just edits. Most damaging failure mode — completely defeats the purpose.

  • Aggressive replacement when annotation was right. When the historical claim is itself a fact (people did believe X), erasing it loses information. Annotate instead.

  • Forgetting the index sweep. A page's body now says "contested" but its index summary still says "primary driver". The index is now lying.

40 files

Advantages

  • Compounding knowledge base that synthesizes information rather than re-reading raw documents on every query. evidence: README.md
  • Automated bookkeeping and cross-referencing reduce manual maintenance effort. evidence: README.md
  • Idempotent scripts ensure reliable operations without external dependencies. evidence: README.md

Limitations

  • Requires strict adherence to the division of labor between the raw source folder and the LLM-managed wiki folder. evidence: README.md
  • Multi-wiki routing requires manual configuration of paths in the schema file. evidence: README.md

Security

Risk level: No risk found

This brain runs

Agent instructions that run or fetch something (8)

  • AGENTS.md: `tests/test_scripts.py`: functional tests that run every script against temp wikis.
  • AGENTS.md: `python3 -m unittest discover -s tests`
  • AGENTS.md: Codex: install from a local marketplace in an isolated `CODEX_HOME`;
  • skills/llm-wiki-manager/SKILL.md: Run them by path relative to this skill's directory, and always pass `--path <wiki-root>`.
  • skills/llm-wiki-manager/SKILL.md: If it is lower than the version this skill expects, offer one sentence before starting the requested work: *"This wiki is at schema v1, the skill expects v2 — run `scripts/migrate_wiki.py` first?"* Don't block the requested operation if the user declines;
  • skills/llm-wiki-manager/SKILL.md: If the section is missing and a multi-wiki operation is requested, **run Schema-evolve first** to add it, then proceed.
  • skills/llm-wiki-manager/SKILL.md: Some users run two wikis: a per-project wiki at the working directory and a long-lived global wiki (often an existing Obsidian vault) at a fixed path.
  • skills/llm-wiki-manager/SKILL.md: unstamped = v1), shows a **dry-run** of the mechanical steps plus the manual (LLM) steps, applies with `--apply` only.

Attribution and licence

Created by
sametbrr
Declared authors
  • sametbrr (declared in .claude-plugin/plugin.json)
Publisher
Samet Birer (Community)
Source
sametbrr/llm-wiki-manager · commit 28ad285
Licence
MIT License (files served here)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by sametbrr.

Download

The ZIP holds the files AutoGineer serves, with ATTRIBUTION.md and the licence. Download llm-wiki-manager.zip