# cdb-scan

Adopt this skill: https://proskills.md/skills/other/avijit07x-claude-db-skills-cdb-scan

Page: https://proskills.md/skills/other/avijit07x-claude-db-skills-cdb-scan
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: skills/cdb-scan/SKILL.md
size: 4257
upstream: https://github.com/avijit07x/claude-db/blob/main/skills/cdb-scan/SKILL.md

````text
---
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.
````

## File: README.md
upstream: https://github.com/avijit07x/claude-db/blob/main/README.md

````text
<img src="./assets/wordmark.svg" alt="claude-db" width="330">

**Free, open-source memory for Claude Code. Your own database, no cloud, no subscription.**

[![npm](https://img.shields.io/npm/v/claude-db.svg)](https://www.npmjs.com/package/claude-db)
[![CI](https://github.com/Avijit07x/claude-db/actions/workflows/ci.yml/badge.svg)](https://github.com/Avijit07x/claude-db/actions/workflows/ci.yml)
[![license](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](./LICENSE)

[Documentation](https://claude-db.vercel.app/docs) ·
[Quick start](https://claude-db.vercel.app/docs/quick-start) ·
[CLI reference](https://claude-db.vercel.app/docs/cli)

---

## 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.

```bash
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](./docs/setup-guide.md) 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](https://claude-db.vercel.app/docs/cli).

## 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](./docs/setup-guide.md): install, head start and habits
- [Documentation site](https://claude-db.vercel.app/docs): CLI, MCP tools,
  databases and troubleshooting
- [With and without](./docs/with-and-without.md) and
  [benchmarks](https://claude-db.vercel.app/docs/benchmarks): the numbers,
  including where plain grep wins
- [Changelog](./CHANGELOG.md)

## Contributing

```bash
npm install
npm run build
npm test
npm run lint
```

[CONTRIBUTING.md](./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](./SECURITY.md), privately.

## License

Apache-2.0
````
