⏳ This skill is pending AI review.
Scores will appear once the review pipeline completes.
cdb-scan
Map this codebase into project memory — a code graph of every symbol and how they connect, plus a written profile of stack, layout, conventions and workflows. Re-run any time to refresh both in place. Use when memory is newly installed on an existing project, or when the project has changed enough that the stored map is stale.
Choose how to use this skill
You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.
1. Native installer
This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.
Do not guess an installer command or replace an existing version without reviewing the diff.
2. Complete package recommended
Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.
No complete ProSkills package is published for this listing yet.3. Prompt-only
Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.
Need only the instruction file?
Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.
No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.
// RATINGS
Not yet listed on ClawHub or SkillsMP
// README
Free, open-source memory for Claude Code. Your own database, no cloud, no subscription.
Documentation · Quick start · CLI reference
Why
Every Claude Code chat starts from zero. You explain the same decisions, dead ends and rules again, and Claude works out what calls what from scratch.
claude-db fixes that. It keeps what you decided and a map of your code, and gives Claude the right part of it at the right time.
What it does
- Remembers across chats. Decisions, dead ends and rules are saved when a chat ends, and the next chat starts by seeing them.
- Recalls what fits. Each prompt gets the one or two earlier memories that match it, and nothing when none fit.
- Maps your code. Who defines, calls or imports a symbol is answered in one call, instead of grep and reading files. It follows imports in TypeScript, JavaScript, Python, Go, Rust, Java and Kotlin.
- Keeps it yours. SQLite on your machine by default, or Postgres or MongoDB to share across machines. No cloud, no subscription.
Install
You need Node 22.16 or newer and a git repository.
npm install -g claude-db
cd your-project
claude-db install --project
Restart Claude Code. There is nothing else to run, because capture and recall are hooks.
Then load what already exists with claude-db flush and claude-db scan. The
setup guide has the rest.
Everyday use
| Where | What it does |
|---|---|
/catchup | Answers "where did I stop?" when you come back |
/handoff | Leaves a short note for the next chat or a mate |
/cdb-scan | Maps an existing codebase into memory |
claude-db status | Shows whether it is wired up and what it recorded |
claude-db doctor | Checks the setup, and finds what is wrong |
claude-db use <url> | Switches to Postgres or MongoDB (pg/mongodb) |
cdb is a shorter alias. Every command is in the
CLI reference.
Privacy
Memory stays in your own database. Two features call Claude Haiku through your
own login, and each has an off switch: claude-db distill off for making facts
from finished chats, and claude-db pick off for choosing memory per prompt.
Once a day it asks npm for the latest version ("updates": "off" stops that).
.env, secrets/, node_modules and .git/ are never stored. Text inside
<private>...</private> is stripped, and API keys and tokens are redacted
before anything is written or sent.
Documentation
- Setup guide: install, head start and habits
- Documentation site: CLI, MCP tools, databases and troubleshooting
- With and without and benchmarks: the numbers, including where plain grep wins
- Changelog
Contributing
npm install
npm run build
npm test
npm run lint
CONTRIBUTING.md has the setup, the rules and the pull request checklist, with links to adding a language and to releasing. Security reports go through SECURITY.md, privately.
License
Apache-2.0
// HOW IT'S BUILT
// FILES
2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.
skills/cdb-scan/SKILL.md4.2 KBupstream ↗
--- name: cdb-scan description: Map this codebase into project memory — a code graph of every symbol and how they connect, plus a written profile of stack, layout, conventions and workflows. Re-run any time to refresh both in place. Use when memory is newly installed on an existing project, or when the project has changed enough that the stored map is stale. --- # Map this project into memory Everything else in claude-db's memory is testimony: it records what happened, turn by turn, as it happened. A fresh install knows none of that, and stays useless for weeks while it fills up. This fills the gap from the one source available on day one — the code itself, in two passes. ## Pass 1 — the code graph Run this first, from the project root: ```bash claude-db scan ``` It parses every supported source file and stores each symbol and each relationship between them: what calls what, what imports what, what extends what. It is deterministic, costs no tokens, and takes seconds. Report the symbol and edge counts it prints. Once it has run, `find_usages` answers structural questions from the graph: - `mode: "usages"` — what references this symbol, with the relation on each line - `mode: "explain"` — that, plus what the symbol itself reaches - `mode: "path"` with `target` — how two symbols connect Prefer those over reading files when the question is about structure. ## Pass 2 — the written profile The graph records what the code _is_. It cannot say why the project is built this way, so the sections below capture that in prose. What you write here is **your reading of the codebase, not a record of events**, so it is tagged `inferred` and must never be phrased as history. Work through the sections below in order. For each one, look at the actual files, then call the `remember` MCP tool once with the given `key`. `key` is what makes this re-runnable: writing the same key again replaces that note rather than adding a second copy. Use these exact keys, and always pass `tags: ["inferred"]` and `kind: "context"`. Before you start, call `search` for `profile` in this project. If notes already exist, read them first and update what changed rather than restating it — a second run should be an edit, not a rewrite. ### 1. `profile:stack` Languages, runtime and version floors, frameworks, package manager, database, test runner, build tool. Read the manifest (`package.json`, `pyproject.toml`, `go.mod`, `Cargo.toml`) and the lockfile rather than guessing. Name versions where a version constrains what can be written. ### 2. `profile:layout` The directory map, one line each, and what lives where. Include the entry points: the binary, the server, the main export. Skip anything generated. ### 3. `profile:conventions` How this codebase is written, taken from the code and not from a style guide: module system, import style, error handling, naming, comment density, how tests are structured. Note where the project deviates from the language default, since that is what someone would otherwise get wrong. ### 4. `profile:workflows` The commands that matter — install, build, test, lint, run, release — and anything non-obvious about running them: a required service, an environment variable, a step that must come first. Take them from the manifest scripts and CI config, not from the README's aspirations. ### 5. `profile:architecture` Only the parts a newcomer could not infer from the layout: the main abstractions and how a request or a command actually flows through them. Two paragraphs at most. If the codebase is small enough that the layout says it all, skip this section rather than padding it. ## Rules - **One `remember` call per section.** Five notes, five stable keys. - **Write claims, not headings.** "Storage is one `MemoryStore` interface with three adapters, selected by URI scheme" — not "Storage architecture". - **Say what you verified.** If something was not read, leave it out. An inferred profile that is confidently wrong is worse than a short one. - **Never restate `CLAUDE.md`.** That file is already in the system prompt on every turn. Memory is for what is not. - **Do not record secrets, credentials or personal data**, even if the code contains them.README.mdupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
Plain-text copy, no login: /skill-bundles/avijit07x-claude-db-skills-cdb-scan.md