rekipedia 0.22.0 → 0.22.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/README.md +179 -120
  2. package/package.json +1 -1
package/README.md CHANGED
@@ -1,8 +1,25 @@
1
+ <div align="center">
2
+
3
+ <img src="https://capsule-render.vercel.app/api?type=waving&color=gradient&customColorList=6,11,20&height=170&section=header&text=rekipedia&fontSize=52&fontColor=ffffff&fontAlignY=38&desc=Turn+any+repo+into+an+AI-ready+knowledge+base&descAlignY=58&descSize=14" alt="Header"/>
4
+
5
+ [![PyPI](https://img.shields.io/badge/PyPI-rekipedia-3776AB?style=for-the-badge&logo=pypi&logoColor=white&labelColor=0d1117)](https://pypi.org/project/rekipedia/)
6
+ [![Python](https://img.shields.io/badge/Python-3.11+-3776AB?style=for-the-badge&logo=python&logoColor=white&labelColor=0d1117)](https://www.python.org/)
7
+ [![License](https://img.shields.io/badge/License-MIT-amber?style=for-the-badge&logo=open-source-initiative&logoColor=white&labelColor=0d1117)](LICENSE)
8
+ [![MCP](https://img.shields.io/badge/MCP-Compatible-8b5cf6?style=for-the-badge&logo=protocols.io&logoColor=white&labelColor=0d1117)](https://modelcontextprotocol.io)
9
+
10
+ </div>
11
+
12
+ ---
13
+
1
14
  # rekipedia
2
15
 
3
- **Turn any repo into an AI-ready knowledge base wiki, RAG, and MCP server included.**
16
+ > **One scan. A living wiki. AI agents that actually know your code.**
17
+ >
18
+ > Parse any codebase into a structured SQLite knowledge store, auto-generate wiki pages, and expose everything via CLI and an MCP stdio server — with file:line citations and zero hallucinations.
4
19
 
5
- [![PyPI version](https://img.shields.io/pypi/v/rekipedia.svg)](https://pypi.org/project/rekipedia/) [![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/) [![MIT License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE) [![MCP](https://img.shields.io/badge/MCP-compatible-purple.svg)](https://modelcontextprotocol.io)
20
+ [![PyPI version](https://img.shields.io/pypi/v/rekipedia.svg)](https://pypi.org/project/rekipedia/)
21
+ [![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/)
22
+ [![MIT License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
6
23
 
7
24
  ---
8
25
 
@@ -13,19 +30,21 @@
13
30
  | "Where does the auth logic live?" | `reki ask "how does auth work?"` → `src/auth.py:42` |
14
31
  | Onboarding new devs takes days | `reki onboard .` generates a guided walkthrough in seconds |
15
32
  | AI agents hallucinate about your codebase | `reki mcp` gives agents a grounded knowledge base with citations |
16
- | Refactor anxiety | `reki hotspots` surfaces hub nodes and bridge nodes before you touch anything |
33
+ | Refactor anxiety — will this break everything? | `reki hotspots` surfaces hub and bridge nodes before you touch anything |
17
34
  | Wiki goes stale immediately | `reki watch .` auto-reindexes on every file save |
18
35
 
19
36
  ---
20
37
 
21
38
  ## ⚡ Quickstart
22
39
 
40
+ ### Install
41
+
23
42
  ```bash
24
43
  pip install rekipedia
25
44
  # or: npx rekipedia
26
45
  ```
27
46
 
28
- ### With LLM (richer wiki + Q&A)
47
+ ### Scan & Ask (with LLM)
29
48
 
30
49
  ```bash
31
50
  export REKIPEDIA_MODEL=gemini/gemini-2.5-flash
@@ -34,9 +53,48 @@ reki scan .
34
53
  reki ask "how does authentication work?"
35
54
  ```
36
55
 
56
+ ### Scan without LLM (zero config, no API key)
57
+
58
+ ```bash
59
+ reki scan . --no-llm
60
+ reki ask "what is the entry point?" --no-llm
61
+ ```
62
+
63
+ ---
64
+
65
+ ## 🏗️ Architecture & Data Storage
66
+
67
+ ```
68
+ .rekipedia/
69
+
70
+ ├── store.db # 🗃️ Structured SQLite graph
71
+ │ └── symbols, relationships, file manifests, scan history
72
+
73
+ ├── rag/
74
+ │ └── faiss.index # 🔍 Dense embedding vectors (FAISS / Qdrant / Chroma)
75
+
76
+ ├── wiki/
77
+ │ └── *.md # 📄 Auto-generated wiki pages per module
78
+
79
+ ├── diagrams/
80
+ │ └── *.md # 🏛️ Architecture diagrams & hotspot reports
81
+
82
+ └── config.yml # ⚙️ Backend, LLM, and team-sync settings
83
+ ```
84
+
85
+ ### Storage at a Glance
86
+
87
+ | Layer | Format | Purpose | Size (typical 50k–200k LOC repo) |
88
+ |---|---|---|---|
89
+ | **SQLite** | `store.db` | Structured graph — symbols, callers, exact lookup | ~10–80 MB |
90
+ | **Vector** | `.rekipedia/rag/` | Dense embeddings for semantic / fuzzy search | ~50–500 MB |
91
+ | **Wiki** | `wiki/*.md` | Human-readable pages, git-publishable | ~1–5 MB |
92
+
93
+ > **Gitignore note:** `store.db` and `rag/` are gitignored — they contain machine-specific absolute paths. Each developer runs `reki scan .` locally. Share human-readable output via `reki publish .`.
94
+
37
95
  ---
38
96
 
39
- ## Key Features
97
+ ## 🚀 Core Features
40
98
 
41
99
  ### 🗂 `reki scan` — Instant knowledge store
42
100
 
@@ -49,15 +107,16 @@ reki scan . --no-llm # zero config, no API key required
49
107
 
50
108
  ### 💬 `reki ask` — Q&A grounded in your code
51
109
 
52
- Answers questions with file:line citations **and real code examples**. No hallucinations — every answer is backed by indexed source, with actual function bodies quoted inline.
110
+ Answers with **file:line citations and real code examples**. No hallucinations — every answer is backed by indexed source, with actual function bodies quoted inline.
53
111
 
54
112
  ```bash
55
113
  reki ask "what is the entry point?"
56
114
  reki ask "which modules handle payments?" --brief
57
115
  ```
58
116
 
117
+ **Example output:**
59
118
  ```
60
- Answer: The entry point is src/main.py:12 — `App.run()` bootstraps the server.
119
+ Answer: The entry point is src/main.py:12 — App.run() bootstraps the server.
61
120
 
62
121
  ```python
63
122
  # src/main.py:12
@@ -69,28 +128,39 @@ def run(self):
69
128
  Sources: src/main.py:12, src/server.py:34
70
129
  ```
71
130
 
72
- **How it works:** rekipedia extracts the actual source bodies of the most relevant functions/classes and passes them directly to the LLM — so answers include real, runnable code, not just paraphrases. When a FAISS index exists (`reki embed .`), RAG chunks are used instead for even higher precision.
131
+ **How it works:** rekipedia extracts actual source bodies of the most relevant functions/classes and passes them directly to the LLM — so answers include real, runnable code, not just paraphrases. When a FAISS index exists (`reki embed .`), RAG chunks are used for even higher precision.
73
132
 
74
133
  ### 🤖 `reki mcp` — MCP server for AI agents
75
134
 
76
- Plug rekipedia directly into Claude Code, Cursor, or any MCP-aware agent.
135
+ Plug rekipedia directly into Claude Code, Cursor, GitHub Copilot, or any MCP-aware agent.
77
136
 
78
137
  ```bash
79
138
  reki mcp
80
139
  ```
81
140
 
82
- Available tools: `ask`, `search_nodes`, `get_context`, `get_relationships`, `get_hub_nodes`, `get_impact`
141
+ **Available MCP tools:**
142
+
143
+ | Tool | Purpose |
144
+ |---|---|
145
+ | `ask` | Natural-language Q&A grounded in the scanned wiki |
146
+ | `search_nodes` | Fast symbol/file lookup by name |
147
+ | `get_context` | Symbols and relationships for a file |
148
+ | `get_relationships` | Callers and callees for a symbol |
149
+ | `get_hub_nodes` | Architectural chokepoints |
150
+ | `get_impact` | Blast-radius for a changed file |
151
+ | `get_knowledge_gaps` | Untested high-call-count symbols |
152
+ | `list_wiki_pages` / `get_wiki_page` | Wiki browsing |
83
153
 
84
154
  ### 🔥 `reki hotspots` — Architectural hotspot detection
85
155
 
86
- Finds hub and bridge nodes the files your whole codebase depends on.
156
+ Finds hub nodes (files many depend on) and bridge nodes (files connecting clusters).
87
157
 
88
158
  ```bash
89
159
  reki hotspots
90
160
  ```
91
161
 
92
162
  ```
93
- Hub nodes: src/core/engine.py (42 dependents)
163
+ Hub nodes: src/core/engine.py (42 dependents)
94
164
  Bridge nodes: src/adapters/db.py (connects 3 clusters)
95
165
  ```
96
166
 
@@ -102,203 +172,192 @@ Only regenerates wiki pages affected by your changes.
102
172
  reki update . --impact-only
103
173
  ```
104
174
 
105
- ---
175
+ ### 🌐 `reki serve` — Local web UI
176
+
177
+ Launch a browsable wiki at `http://127.0.0.1:7070`.
106
178
 
107
- ## MCP Integration
179
+ ```bash
180
+ reki serve .
181
+ ```
108
182
 
109
- rekipedia ships a full MCP stdio server. Connect it to any MCP-aware agent in seconds.
183
+ ### 📤 `reki publish` Team sharing
110
184
 
111
- Add to your `.mcp.json`:
185
+ Copy generated wiki into a git-tracked directory for team browsing.
112
186
 
113
- ```json
114
- {
115
- "mcpServers": {
116
- "rekipedia": {
117
- "command": "reki",
118
- "args": ["mcp"],
119
- "cwd": "."
120
- }
121
- }
122
- }
187
+ ```bash
188
+ reki publish . [--output-dir PATH]
123
189
  ```
124
190
 
125
- Claude Code and Cursor will automatically discover this config. The agent can then call:
191
+ ---
192
+
193
+ ## 🛠️ Commands Cheat Sheet
194
+
195
+ | Command | Description |
196
+ |---|---|
197
+ | `reki scan .` | Full scan — index symbols, generate wiki |
198
+ | `reki scan . --no-llm` | Scan without LLM, zero config |
199
+ | `reki ask "question"` | Ask anything about the codebase |
200
+ | `reki ask "question" --brief` | Short answer mode |
201
+ | `reki update . --impact-only` | Incremental update, affected pages only |
202
+ | `reki serve .` | Local web UI at `http://127.0.0.1:7070` |
203
+ | `reki embed .` | Build FAISS semantic index |
204
+ | `reki publish . [--output-dir PATH]` | Publish wiki to a git-tracked directory |
205
+ | `reki export . --format bundle` | Export a content-addressed wiki bundle |
206
+ | `reki merge <bundle-A> <bundle-B> [--base BASE]` | Three-way conflict-free wiki merge |
207
+ | `reki pull [URL]` | Fetch and merge a remote wiki bundle |
208
+ | `reki watch . --publish` | Auto-index + auto-publish on every file save |
209
+ | `reki export . --format md\|zip\|json\|html\|bundle` | Export the wiki |
210
+ | `reki diff` | Show impact of uncommitted changes |
211
+ | `reki hotspots` | Hub & bridge node detection |
212
+ | `reki refactor . --dry-run` | Preview refactor suggestions |
213
+ | `reki refactor . --apply` | Apply refactor suggestions |
214
+ | `reki mcp` | Start MCP stdio server |
215
+ | `reki review` | LLM-powered PR review |
216
+ | `reki hook install` | Install git post-commit hook |
217
+ | `reki init --with-all-ai` | Configure MCP for Copilot + Codex + Cursor |
218
+ | `reki init --with-ci` | Scaffold GitHub Actions workflow for auto-wiki |
126
219
 
127
- - `ask` — Q&A over the codebase
128
- - `search_nodes` — symbol/file search
129
- - `get_context` — file-level context
130
- - `get_relationships` — dependency graph queries
131
- - `get_hub_nodes` — architectural hotspots
132
- - `get_impact` — change impact analysis
133
- - `list_wiki_pages` — enumerate all wiki pages
134
- - `get_wiki_page` — read a specific wiki page by name
135
220
  ---
136
- ## AI CLI tool integration
137
221
 
138
- rekipedia integrates natively with the major AI coding assistants via MCP (Model Context Protocol). After scanning your codebase, run:
222
+ ## 🤖 AI CLI Tool Integration
139
223
 
140
224
  ```bash
141
225
  reki init --with-all-ai # configure Copilot + Codex + Cursor in one step
226
+
142
227
  # or pick individually:
143
- reki init --with-copilot # GitHub Copilot (VS Code) — writes .vscode/mcp.json
144
- reki init --with-codex # Codex CLI — writes .codex/instructions.md + setup hint
228
+ reki init --with-copilot # VS Code — writes .vscode/mcp.json
229
+ reki init --with-codex # Codex CLI — writes .codex/instructions.md
145
230
  reki init --with-cursor # Cursor — writes .cursor/mcp.json + rules
146
231
  ```
147
232
 
148
- Once configured, each tool automatically gets access to these rekipedia MCP tools:
149
-
150
- | MCP Tool | What it does |
151
- |---|---|
152
- | `ask` | Natural-language Q&A grounded in the scanned wiki |
153
- | `search_nodes` | Fast symbol lookup by name |
154
- | `get_context` | Symbols and relationships for a file |
155
- | `get_relationships` | Callers and callees for a symbol |
156
- | `get_hub_nodes` | Architectural chokepoints |
157
- | `get_impact` | Blast-radius for a changed file |
158
- | `get_knowledge_gaps` | Untested high-call-count symbols |
159
- | `list_wiki_pages` | List all wiki pages |
160
- | `get_wiki_page` | Read a specific wiki page by name |
233
+ Once configured, each tool automatically gets access to the [MCP tools listed above](#-reki-mcp--mcp-server-for-ai-agents).
161
234
 
162
235
  ---
163
236
 
164
- ## LLM Setup
237
+ ## ⚙️ LLM Setup
165
238
 
166
- rekipedia works without an LLM (`--no-llm`). To enable richer summaries and Q&A:
239
+ rekipedia works **entirely without an LLM** (`--no-llm`). To enable richer summaries and Q&A:
167
240
 
168
241
  ```bash
169
242
  export REKIPEDIA_MODEL=gemini/gemini-2.5-pro
170
243
  export GOOGLE_API_KEY=...
171
244
  ```
172
245
 
173
- Or use a provider-agnostic key:
246
+ Or use any OpenAI-compatible endpoint:
174
247
 
175
248
  ```bash
176
249
  export REKIPEDIA_MODEL=openai/gpt-4o
177
250
  export REKIPEDIA_API_KEY=sk-...
178
- ```
179
-
180
- Any OpenAI-compatible endpoint works:
181
251
 
182
- ```bash
252
+ # Local / offline
183
253
  export REKIPEDIA_API_KEY=ollama
184
254
  export REKIPEDIA_MODEL=ollama/llama3
185
255
  ```
186
256
 
187
257
  ---
188
258
 
189
- ## Commands
259
+ ## ❓ FAQ
190
260
 
191
- | Command | Description |
192
- |---|---|
193
- | `reki scan .` | Full scan index symbols, generate wiki |
194
- | `reki scan . --no-llm` | Scan without LLM, zero config |
195
- | `reki ask "question"` | Ask anything about the codebase |
196
- | `reki ask "question" --brief` | Short answer mode |
197
- | `reki update . --impact-only` | Incremental update, affected pages only |
198
- | `reki serve .` | Local web UI at `http://127.0.0.1:7070` |
199
- | `reki embed .` | Build FAISS semantic index |
200
- | `reki publish . [--output-dir PATH]` | Publish wiki to a git-tracked directory for team sharing |
201
- | `reki export . --format bundle` | Export a content-addressed wiki bundle for team sync |
202
- | `reki merge <bundle-A> <bundle-B> [--base BASE]` | Three-way wiki merge — conflict-free team sync |
203
- | `reki pull [URL]` | Fetch and merge a remote wiki bundle (HTTPS/S3/GCS) |
204
- | `reki watch . --publish` | Auto-index + auto-publish wiki on every file save |
205
- | `reki export . --format md\|zip\|json\|html\|bundle` | Export the wiki |
206
- | `reki diff` | Show impact of uncommitted changes |
207
- | `reki hotspots` | Hub & bridge node detection |
208
- | `reki refactor . --dry-run` | Preview refactor suggestions |
209
- | `reki refactor . --apply` | Apply refactor suggestions |
210
- | `reki mcp` | Start MCP stdio server |
211
- | `reki review` | LLM-powered PR review |
212
- | `reki watch .` | Auto-index on file change |
213
- | `reki hook install` | Install git post-commit hook |
214
- | `reki init --with-all-ai` | Configure MCP for GitHub Copilot, Codex CLI, and Cursor in one step |
261
+ **Q: Why is `store.db` gitignored? How do teammates use rekipedia?**
262
+
263
+ `store.db` contains machine-specific absolute paths — committing it would cause path mismatches and noisy binary diffs. Each developer runs `reki scan .` locally. To share human-readable output, use `reki publish .`, which copies generated wiki pages to `docs/wiki/` so they can be committed and browsed on GitHub or your docs site.
215
264
 
216
265
  ---
217
266
 
218
- ## FAQ
267
+ **Q: What is `store.db` for vs the FAISS index? Why do I need both?**
219
268
 
220
- ### Q: Why is `store.db` gitignored? How do teammates use rekipedia?
269
+ | | `store.db` | FAISS / Qdrant / Chroma |
270
+ |---|---|---|
271
+ | **Format** | Structured SQLite graph | Dense embedding vectors |
272
+ | **Purpose** | Precise filters — "find all callers of function X" | Fuzzy semantic search — "find code that handles authentication" |
273
+ | **Used by** | `search_nodes`, `get_relationships`, `hotspots` | `reki ask` RAG pipeline |
221
274
 
222
- `store.db` is a binary SQLite file containing machine-specific absolute paths — committing it would cause path mismatches on other machines and create noisy binary diffs. Each developer runs `reki scan .` locally to build their own store. To share the human-readable output with your team, use `reki publish .`, which copies the generated wiki pages to `docs/wiki/` so they can be committed and browsed in your repo or docs site.
275
+ `reki ask` uses both: BM25 keyword search over SQLite **plus** vector similarity search, then merges and re-ranks results.
223
276
 
224
277
  ---
225
278
 
226
- ### Q: What is `store.db` for vs the FAISS index? Why do I need both?
279
+ **Q: Can I use Postgres or MySQL instead of SQLite?**
227
280
 
228
- They serve distinct purposes and are not interchangeable. `store.db` is a structured SQLite graph: it stores symbols, relationships, file manifests, and scan run history — the kind of data you query with precise filters ("find all callers of function X"). The FAISS index (built by `reki embed .`) stores dense embedding vectors for every chunk of your codebase, enabling fuzzy semantic search ("find code that handles authentication"). `reki ask` uses both together: BM25 keyword search over SQLite and vector similarity search over FAISS, then merges the results.
281
+ Not currently. SQLite is intentional zero-config, portable, no running server. `reki export .` produces `symbols.json` and `relationships.json` for loading into any database. Postgres/MySQL support is not on the roadmap, but the JSON exports make integration straightforward.
229
282
 
230
283
  ---
231
284
 
232
- ### Q: Can I use Postgres, MySQL, or another database instead of SQLite?
233
-
234
- Not currently. SQLite is the only supported backend for the structured symbol/relationship store, and it is intentional — SQLite is zero-config, portable, and requires no running server, which keeps `reki scan` self-contained. The `reki export .` command produces JSON exports (`symbols.json`, `relationships.json`) you can load into any database. Postgres/MySQL support is not on the roadmap, but the JSON exports make integration with your own tooling straightforward.
285
+ **Q: Does rekipedia support Qdrant or Chroma instead of FAISS?**
235
286
 
236
- ---
287
+ Yes. FAISS is the default, but Qdrant and Chroma are supported as optional backends — useful for shared, persistent vector stores across a team. Install extras:
237
288
 
238
- ### Q: Does rekipedia support Qdrant or Chroma instead of FAISS?
289
+ ```bash
290
+ pip install rekipedia[qdrant] # or rekipedia[chroma]
291
+ ```
239
292
 
240
- Yes. FAISS is the default vector backend, but Qdrant and Chroma are both supported as optional backends. Qdrant and Chroma are useful when you want a persistent, server-hosted vector store shared across machines — unlike the local FAISS index, a running Qdrant or Chroma instance can be queried by your whole team without each person running `reki embed`. Install the relevant extras (`pip install rekipedia[qdrant]` or `rekipedia[chroma]`) and configure the backend in `.rekipedia/config.yml`.
293
+ Then configure the backend in `.rekipedia/config.yml`.
241
294
 
242
295
  ---
243
296
 
244
- ### Q: Do I need an OpenAI API key?
297
+ **Q: Do I need an OpenAI API key?**
245
298
 
246
- No. rekipedia can run entirely without an LLM using the `--no-llm` flag — `reki scan . --no-llm` performs static analysis only, producing the symbol graph and wiki structure without AI-generated summaries. When you do want richer summaries and Q&A, rekipedia supports OpenAI, Anthropic, Ollama (local), Azure OpenAI, and any OpenAI-compatible endpoint. For fully offline usage, point it at a local [Ollama](https://ollama.com) instance — no internet required.
299
+ No. `reki scan . --no-llm` performs static analysis only fully offline and air-gap safe. When LLM features are enabled, only retrieved chunks (not your full source) are sent as context. Use [Ollama](https://ollama.com) for fully local inference — no internet required.
247
300
 
248
301
  ---
249
302
 
250
- ### Q: How do I share the wiki with my team without everyone running `reki scan`?
303
+ **Q: How do I keep the wiki up to date automatically?**
251
304
 
252
- Use `reki publish .`. This command copies the generated `wiki/*.md` and `diagrams/*.md` files into `docs/wiki/` (not gitignored), which can be committed and browsed directly in GitHub, your docs site, or any Markdown viewer — no local scan required. The best setup is to automate publishing in CI so the wiki stays current whenever the main branch changes (see the GitHub Actions question below).
305
+ Run `reki init --with-ci` to scaffold a GitHub Actions workflow that runs `reki scan` + `reki publish` on every push to `main`. The workflow commits changes to `docs/wiki/` back to the repo automatically. Set `REKIPEDIA_API_KEY` as a repository secret for LLM-enriched pages; omit it and the workflow falls back to `--no-llm` at zero cost.
253
306
 
254
307
  ---
255
308
 
256
- ### Q: How do I keep the wiki up to date automatically?
309
+ **Q: How does team sync work for distributed teams?**
310
+
311
+ rekipedia uses a multi-layer, conflict-free collaboration system:
257
312
 
258
- Run `reki init --with-ci` to scaffold a GitHub Actions workflow (`.github/workflows/rekipedia-wiki.yml`) that runs `reki scan`, then `reki publish` on every push to `main`. The workflow commits any changes to `docs/wiki/` back to the repo automatically. Set `REKIPEDIA_API_KEY` as a repository secret for LLM-enriched pages; omit it and the workflow falls back to `--no-llm` mode at zero cost.
313
+ 1. **Bundle** `reki export --format bundle` creates a deterministic, content-addressed snapshot.
314
+ 2. **Merge** — `reki merge bundle-A bundle-B --base bundle-base` performs a three-way merge with automatic resolution for non-conflicting changes.
315
+ 3. **Git merge driver** — `reki init --with-merge-driver` registers a custom driver so `git merge` and `git pull` use rekipedia's logic — no `<<<<<<` conflicts in generated wiki files.
316
+ 4. **Live sync** — `reki watch . --publish` publishes the wiki after every incremental update.
317
+ 5. **Remote pull** — `reki pull <url>` fetches a bundle from HTTPS, S3, or GCS and merges it locally.
259
318
 
260
319
  ---
261
320
 
262
- ### Q: How does team sync work for distributed teams?
321
+ **Q: How does `reki ask` work under the hood?**
263
322
 
264
- rekipedia's team sync is a multi-layer system for conflict-free wiki collaboration:
323
+ A hybrid retrieval pipeline:
265
324
 
266
- 1. **Bundle** `reki export --format bundle` creates a deterministic, content-addressed snapshot with a stable `bundle_id` and per-page hash trailers.
267
- 2. **Merge** `reki merge bundle-A bundle-B --base bundle-base` performs a three-way merge: pages changed by only one developer are accepted automatically; only genuinely divergent pages produce conflict markers.
268
- 3. **Git merge driver** `reki init --with-merge-driver` registers a git merge driver so `git merge` and `git pull` automatically use rekipedia's merge logic — no `<<<<<<` conflicts in generated wiki files.
269
- 4. **Live sync** — `reki watch . --publish` publishes the wiki after every incremental update, keeping `docs/wiki/` in sync as you code. Set `team.sync_dir` in `.rekipedia/config.yml` for the default target.
270
- 5. **Remote pull** — `reki pull <url>` fetches a bundle from HTTPS, S3, or GCS and merges it locally. Combine with `reki init --with-ci --with-upload s3` to have CI upload a fresh bundle after every main-branch push.
325
+ 1. **BM25 keyword search** against the SQLite store for exact and near-exact matches.
326
+ 2. **Vector similarity search** against FAISS/Qdrant/Chroma for semantic matches.
327
+ 3. **Merge & re-rank** the two result sets by relevance score.
328
+ 4. **LLM synthesis** — top chunks passed to your configured LLM with file:line citations.
271
329
 
272
- ---
330
+ With `--no-llm`, retrieval results are returned directly without synthesis.
273
331
 
274
- ### Q: How does `reki ask` actually work under the hood?
332
+ ---
275
333
 
276
- `reki ask "question"` runs a hybrid retrieval pipeline. First, it executes a BM25 keyword search against the SQLite store to find exact and near-exact symbol/token matches. In parallel, it encodes your question into an embedding vector and queries the FAISS (or Qdrant/Chroma) index for semantically similar chunks. The two result sets are merged and re-ranked by relevance score, then the top chunks are passed as context to your configured LLM, which synthesises a final answer with file:line citations. With `--no-llm`, retrieval results are returned directly without synthesis.
334
+ **Q: How large does `store.db` / the FAISS index get on a large repo?**
277
335
 
278
- ---
336
+ For a typical mid-size repo (50k–200k LOC):
279
337
 
280
- ### Q: How large does `store.db` / the FAISS index get on a large repo?
338
+ | Storage | Typical Size |
339
+ |---|---|
340
+ | `store.db` | 10–80 MB |
341
+ | FAISS index | 50–500 MB |
281
342
 
282
- For a typical mid-size repo (50k–200k lines of code), `store.db` is usually 10–80 MB. The FAISS index in `.rekipedia/rag/` scales with the number of embedded chunks — expect 50–500 MB for the same size range, which is why `rag/` is gitignored by default. On very large monorepos (1M+ LOC), the FAISS index can exceed 1 GB; in that case, switching to a server-backed Qdrant instance is recommended so the index lives outside your working directory.
343
+ On very large monorepos (1M+ LOC), the FAISS index can exceed 1 GB; switching to a server-backed Qdrant instance is recommended.
283
344
 
284
345
  ---
285
346
 
286
- ### Q: Can rekipedia scan private or fully offline repos?
347
+ **Q: Can rekipedia scan private or fully offline repos?**
287
348
 
288
- Yes, fully. `reki scan` is pure static analysis — it never sends your source code anywhere. With `--no-llm`, the entire pipeline is offline and air-gap safe. When LLM features are enabled, only retrieved *chunks* (not your full source) are sent to the LLM provider as context; if you use Ollama, even that stays local. There are no telemetry calls, no license checks against a remote server, and no requirement for internet access beyond reaching your chosen LLM API endpoint.
349
+ Yes, fully. `reki scan` is pure static analysis — it never sends your source code anywhere. With `--no-llm`, the entire pipeline is offline and air-gap safe. There are no telemetry calls, no license checks against a remote server, and no internet requirement beyond your chosen LLM endpoint.
289
350
 
290
351
  ---
291
352
 
292
- ## Coming Soon
353
+ ## 🔮 Coming Soon
293
354
 
294
355
  - **Hosted wiki** — share your knowledge base with a link, no self-hosting required
295
356
  - **VS Code extension** — inline `reki ask` from your editor
296
357
 
297
358
  ---
298
359
 
299
- ## Contributing
300
-
301
- rekipedia is going MIT open source. Contributions welcome.
360
+ ## 🤝 Contributing
302
361
 
303
362
  ```bash
304
363
  git clone https://github.com/unrealandychan/rekipedia.git
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "rekipedia",
3
- "version": "0.22.0",
3
+ "version": "0.22.1",
4
4
  "description": "Agentic repo-to-wiki: scan any repository into a portable SQLite knowledge store with wiki pages, diagrams, and grounded Q&A.",
5
5
  "bin": {
6
6
  "rekipedia": "./bin/rekipedia.js"