ContextZero

One place to see and manage what every AI coding agent knows — across all your projects.

A VS Code extension that gives you one sidebar, split into Context, Prompts, and Templates panels, for the memory, rules, and skills used by Claude Code, Cursor, Kiro, Antigravity, and the shared AGENTS.md standard, for every project on your machine — including monorepos, where sub-projects nest under their parent — plus safe recovery of Claude Code memory and chat history when you rename or move a project folder.

Built by Tahir Nazir — its-tahir.com

Why this exists

If you use more than one AI coding tool, each one keeps its own rules, memory, and knowledge files — scattered across your home directory and every project folder, with no shared view. There's no single place to see what Claude Code, Cursor, Kiro, Antigravity, and the tool-neutral AGENTS.md standard each know about a project, or what your global rules say for each of them.

Claude Code adds a second, separate problem on top of that: it stores per-project data under ~/.claude/projects/<slug>/, where the slug is derived from your project folder's path. Rename or move a project folder and Claude starts fresh — your chat history and memory sit orphaned under the old slug.

ContextZero solves both. It gives you one project-first sidebar tree spanning all five tools — nesting monorepo sub-projects under their parent — and — specific to Claude Code — it can safely relink a renamed project and recover its memory and chat history, all under a strict safety model: it never deletes a single file, and rewrites exactly one kind of file — an MCP config you asked it to add a server to (details). It also ships a library of reusable prompts and rule/skill templates you can copy or apply to any project, and a per-project readiness check.

Features

Platform support. Project folder decoding — which drives the ⚠ "(folder missing)" badge and the relink flow — works with both Windows (d--dev-project) and macOS/Linux (-Users-you-dev-project) path formats. Windows is the platform ContextZero is developed and manually tested on; macOS and Linux decoding is covered by unit tests but has not yet been exercised on real hardware. If you hit something wrong on either, please open an issue — that feedback is genuinely useful.

Library

Two extra panels under the ContextZero icon:

• Prompts — built-in starter prompts (onboard a codebase, systematic debug, new-feature kickoff, write tests, code review) plus your own. Click the copy button to put a prompt on the clipboard, ready to paste into any agent. Copy to My Library forks a built-in into ~/.contextzero/prompts/ so you can customise it.
• Templates — rule templates (Frontend, Backend, Code quality) and a skill template (Systematic debugging). Apply to Project… writes the rules into a project as AGENTS.md, GEMINI.md, or CLAUDE.md (never overwriting), or for a skill template, asks where to install it (Antigravity or Claude Code, project or global — the same destination picker as Install Skill…).

Your custom prompts and templates live in ~/.contextzero/ as plain Markdown.

Prompt placeholders

A prompt can reference the file you're working in, your selection, the workspace folder, or a live git diff — filled in only at copy/install time, never baked into the saved prompt itself:

Copy Prompt fills every placeholder it can and copies the result to the clipboard. Anything it can't resolve — no active editor, no git repository — is left in the copied text exactly as written ({{diff}}, never an empty string) and named in the confirmation message.

Install as Command… turns a prompt into a real slash command inside an agent's own command folder:

Antigravity has no global workflows directory, so it only ever offers a project destination. {{args}} maps to that agent's own argument syntax ($ARGUMENTS for Claude Code, left as-is for Cursor, and Antigravity gets a required description frontmatter block added automatically if the prompt doesn't already have one). Editor-context placeholders ({{file}}, {{selection}}, {{diff}}, {{project}}) can't be represented in a file that has to work for every future run — installing still proceeds, but warns you first which of them will reach the agent literally, unfilled. Like everything else in ContextZero, an existing command file is never overwritten; you're told and it opens instead.

Mirroring rules files

Each project in the Context panel also shows a Readiness line — which of CLAUDE.md, AGENTS.md, GEMINI.md, and memory it has — with a one-click + to create most missing files (GEMINI.md is shown for awareness only). When a missing file has a sibling that already exists in the same project, the row offers Mirror from… instead: it copies that sibling's content into the missing file, prefixed with a provenance comment (<!-- Generated by ContextZero from CLAUDE.md on 2026-07-23. -->) so Context Health can tell a mirror apart from a genuine duplicate and flag it if the source changes afterwards. Mirroring never overwrites an existing file.

Team library sources

Point ContextZero at libraries your whole team shares:

Featured libraries

On first launch, the Templates panel shows a Featured section above your own sources — a curated list of known-good skill libraries, dimmed as "click to get" rows, so you never have to go find and paste a git URL yourself. The bundled list ships three entries:

Clicking a Featured row shows the exact same confirmation dialog as Add Library Source… below — naming the real URL and target directory — then clones it; the row then moves out of Featured and into your own sources.

The list also refreshes from a remote catalog (contextZero.featuredCatalogUrl) so entries can be added or withdrawn without an extension update. That is one HTTPS GET of a small JSON file when the extension starts — no personal data, no telemetry, and it happens without prompting you. If it fails for any reason, the cached and then bundled list is used and nothing is reported to you. No repository is ever cloned without you clicking a row and confirming the dialog. Set contextZero.showFeaturedLibraries to false to skip the fetch and hide the section entirely, or contextZero.featuredCatalogUrl to "" to keep the section but never fetch.

Add Library Source… on the Templates panel clones a repo (shallow, and narrowed to the library folders). Big catalogs — such as agentic-awesome-skills with ~1,969 skills — appear as one row grouped A–Z, and descriptions are read only when you expand a letter.

If a clone or pull fails (no git, a private repo, a timeout, no network), the source still appears in the tree with a ⚠ not downloaded — use Update row instead of silently vanishing — retry with its Update Source button once the problem is fixed. Right-click a git source for Remove Library Source… to drop it from contextZero.librarySources and delete its managed clone.

ContextZero: Search Skills searches skill names and descriptions — descriptions become searchable once that source's index has finished building in the background after a clone or pull — across every source. It does not search prompts or rule templates.

Install Skill… copies a whole skill folder (its SKILL.md plus any scripts/, examples/) into:

Files that already exist are skipped and reported, never overwritten — there is no confirmation dialog for this one; it goes straight to a destination picker.

Skills come from library sources you or your team point ContextZero at — often third-party repos — and may include scripts/. Installing a skill places that content where your agent can read and run it, same as any file in your project. Only add sources you trust.

An installed skill used to stay frozen forever: pulling its source repo refreshed the clone but never the copy you'd already installed, with nothing in the UI to say so. Now, once an installed skill's files differ from its source, it shows an update available badge in the Context tree. Right-click it for:

• Update Skill… — moves the installed folder to ~/.contextzero/backups/<timestamp>/<id>/ and copies the source folder fresh — nothing is deleted and nothing is written over. The backup lands in ContextZero's own folder on purpose: a <id>.backup-<timestamp>/ left beside the skill would still contain a SKILL.md, and your agent would load it as a second copy of the skill you just updated. If a backup of that exact path already exists, the update aborts and leaves the installed skill untouched rather than overwrite it.
• Show what changed — opens a diff of the installed SKILL.md against the source's.

Bootstrap Project… on a project applies a team standard defined in a bootstrap.json inside any library source, so the standard is versioned with your team's library:

{ "profiles": [ { "name": "Backend service",
  "rules": [{ "template": "backend", "target": "AGENTS.md" }],
  "skills": ["systematic-debugging"] } ] }

ContextZero manages ~/.contextzero/sources/ (clones and the search index) and may delete or re-create what's under it. See Safety model for the full boundary.

Context Health

Each project in the Context panel gets a Context Health row, next to Readiness, that reports:

• Duplicated rules — the same block of at least 3 lines repeated across two or more of a project's own rules files.
• Global/project overlap — a rule present in both your global Claude Code CLAUDE.md and this project's copy — called out as "sent twice on every turn" specifically when it's the same file name in both scopes.
• Mirror drift — a file created by Mirror from… whose source has changed since, so the mirror is now stale.
• Oversized files — a rules file estimated at 4,000+ tokens (roughly four characters per token), sent to the agent in full on every turn.

Click any finding to open the file at the offending line. The analysis is deferred — it never runs during project discovery, a background scan, or a refresh. It runs when you expand a project, because the collapsed Context Health row's own label has to say how many issues there are; the result is then cached per project until the next refresh. Per file, it examines only the first 1,500 normalised lines (blank lines, headings, and fenced code don't count against that limit). A file past that size shows a note saying analysis stopped there, rather than a clean result you could mistake for "the whole file was checked." Hide the section entirely with contextZero.contextHealth: false.

MCP servers

Each project (and Global) gets an MCP Servers row listing every configured server across the tools that support them:

Reading is lazy: nothing is opened until you expand the row, and the result is cached until the next refresh. A missing config file just shows "none configured" — it's not an error.

Values are never shown. A server's row displays only its name, transport (stdio/http), and either its command or its host — plus a count like "2 env vars" when it has environment variables. No API key, token, or other credential value is ever rendered, logged, or copied.

~/.claude.json is read-only. It's ~69 KB of unrelated Claude Code state (project history, settings) alongside its MCP servers, and re-serialising the whole file to insert one entry risks damaging data this feature has no business touching. Antigravity's global settings.json is read-only for the same reason — MCP servers are one section of a larger settings file. ContextZero only ever reads either file.

Copy to…, on a server row, translates that server into another tool's config format — the tools disagree on the root JSON key (mcpServers for Claude Code and Cursor, servers for VS Code), so a config block copy-pasted directly between them doesn't work. Pick a destination from any writable config (global or any project); the server is inserted under its new tool's key. No existing server is ever overwritten — if a server of that name already exists at the destination, nothing is written and the file opens so you can look. Environment variable names and any credential-bearing command-line arguments are copied with empty values; the confirmation message names exactly which ones you need to fill in before the copied server will work.

For an HTTP server, the row displays only the scheme and host, but the copied config keeps the full path — https://mcp.notion.com/mcp copies as https://mcp.notion.com/mcp, not as a dead https://mcp.notion.com. What is stripped is the part of a URL that actually carries credentials: the query string (?token=…) and any user:password@ in front of the host. If either was present, the notification tells you the URL was changed so you can check it.

.vscode/mcp.json may legally contain comments (VS Code writes them itself), and ContextZero reads them fine. Adding a server to such a file rewrites it as plain JSON, so the comments in that one file are not preserved — you're told before and after it happens.

Hide the whole MCP feature — this section and the MCP Library — with contextZero.showMcpServers: false.

MCP Library

The Templates panel has an MCP Library section for the other side of MCP: finding and installing a server, instead of managing ones you already have.

Featured MCP

It leads with a Featured MCP list — a 14-entry, hand-verified shortlist of official servers (GitHub, Sentry, Stripe, Notion, MongoDB, Supabase, Vercel, Linear, Playwright, Figma, Atlassian, Airtable, Cloudflare, Neon) as rows you can click to install directly. Below it, Search all servers… searches the official MCP registry live for anything else.

Featured MCP refreshes the same way Featured libraries does: on startup, ContextZero fetches contextZero.mcpCatalogUrl (a small JSON file) and, if it parses and has usable entries, replaces the list and caches it to ~/.contextzero/mcp-catalog.json; a failed or empty fetch falls back to that cache and then the bundled shortlist, silently — nothing is ever merged, and nothing is reported to you either way. Set contextZero.mcpCatalogUrl to "" to rely only on the bundled/cached list.

Search results always show the full namespaced publisher name alongside the title — e.g. Playwright — ai.smithery/playwright — never just a friendly title. The registry is dominated by aggregator re-publishers: a live search for "playwright" returned six servers from four different publishers, so the publisher is the only way to tell them apart. Only the exact server already in the active Featured MCP list (same package or same URL) is filtered out of the results — searching "github" still shows every other publisher's GitHub server.

Clicking a row (bundled or search result) walks you through:

1. Pick which config to install into — any writable destination from the same list as MCP servers above (~/.claude.json and Antigravity's settings.json stay off-limits, same as there).
2. A modal confirms the exact file and the exact command line or URL that will be written, plus the names of any environment variables — you approve what your agent will later run, not just a server name. The executable name itself is only ever one of npx, uvx, node, python, python3, or uv; a registry entry naming anything else falls back to the default for its package type.
3. Never overwrites another server — a server of that name already at the destination aborts the write and opens the file instead, same as Copy to….
4. A server with no npm, PyPI, or HTTP package listed in the registry (for example, an OCI-image-only entry) is reported as not installable rather than written as a broken half-entry. Registry-supplied runtime arguments (arguments to npx/uvx) and package arguments (arguments to the server) are both written, in the right order, so a server that needs them isn't installed half-configured.

ContextZero never asks for, stores, or transmits a credential. Required environment variables are written to the file as names with empty values; optional ones are omitted entirely. After writing, the notification lists exactly which variables need filling in, along with their descriptions, and the file opens with the first empty one already selected so you can paste the value straight in.

Every network failure — an unreachable registry, a bad response — degrades quietly to the Featured MCP shortlist: an informational message and an output channel line, never a popup stack trace. Set contextZero.mcpRegistryUrl to empty to disable live search entirely and rely only on Featured MCP.

MCP Gaps

Each project (and Global, empty-env findings only) gets an MCP Gaps row, next to Readiness and Context Health, built from the same lazily-read, cached config data as MCP servers above — expanding it never reads anything MCP Servers hasn't already read this session. It reports:

• Missing elsewhere — a server configured in one tool's project config but absent from another writable tool's project config for the same project. Click for a quick Copy to… straight to that destination, or to open the source file.
• Empty env — a server with one or more environment variables still set to "". Click opens the file with the first one selected, same as the post-install reveal in the MCP Library.
• Read-only-only — a server that exists only in a read-only config (~/.claude.json, Antigravity's settings.json) and nowhere writable — informational, since there's nothing ContextZero can offer to fix.

Every label shows names and counts only — never a value. Hidden along with the rest of MCP by contextZero.showMcpServers: false.

Export Context Pack

Export Context Pack… — from the command palette or a project's right-click menu — bundles a project's rules, Claude memory, and (opt-in) skill folders into a fresh folder you choose, named context-pack-<project>-<stamp>/, plus a MANIFEST.md listing everything in it. MCP servers appear in the manifest by name, transport, and host only — never a config body, never a credential — and .credentials.json, *.db, and any mcp.json/.mcp.json are hard-excluded regardless of what you pick.

• Include options default to rules and memory on, whole skill folders off — a skill can carry scripts, so packing one is an explicit opt-in every time.
• Never overwrites: a pack folder name that already exists at the chosen destination fails with a message instead of merging into it.
• Afterwards you're offered Reveal in Folder and Create Zip (built via Compress-Archive on Windows or zip elsewhere, argument arrays only) — the zip is a separate, stamped file; it's never the only copy of the pack.

Context Gaps

Each project gets a Context Gaps row — separate from Readiness and Context Health — for two specific cross-tool findings, computed from the workspace model plus cheap file-existence checks (never file content, so it can never duplicate Context Health's mirror-drift finding):

• Rules missing — CLAUDE.md exists but AGENTS.md doesn't (so any tool that only reads AGENTS.md sees nothing), or AGENTS.md exists but Cursor has no project rules of its own. Click offers Mirror from… when there's a sibling to generate from, otherwise Create….
• Tool silent — an enabled provider (Cursor, Kiro, Antigravity) has zero project context files while at least one other enabled provider has some. Click offers Add Context File… filtered to that tool.

Hide it with contextZero.contextGaps: false.

Get started tips

The first time the Context tree has no projects and no global files to show, a Get started section appears at the top instead of a blank panel:

• Set scan roots to find your projects…
• Browse Featured libraries… / Browse Featured MCP servers… (both focus the Templates panel)
• Refresh
• Dismiss these tips

Nothing here fetches, clones, or installs anything on its own — every row just opens an existing settings entry, panel, or command. The section disappears on its own once a project or global file exists, and clicking any row (not only Dismiss) marks it seen (globalState contextZero.seenWelcome) so it doesn't come back. Turn it off entirely with contextZero.showWelcomeTips: false.

Providers

Tools you don't use never appear in the tree.

Verification status: Claude Code and Cursor layouts are verified against real installations. Antigravity's project-root GEMINI.md context file was also found on a real install, and is listed alongside .antigravityrules. Kiro's steering paths and Antigravity's knowledge and skills directories (global and per-project) come from public documentation rather than a populated install of either tool — they're now fixture-verified: the repo's test fixtures (fixtures/home/.kiro, fixtures/home/.gemini, fixtures/home/work/demo-proj) and tests/providerKiroAntigravity.test.ts exercise every documented path, so a layout change would be caught here, but that's still not the same guarantee as hardware. If you use Kiro or Antigravity and something looks wrong, please open an issue.

Settings

Safety model

• Never deletes your files, and overwrites exactly one kind of file — see the next bullet. Everything else is append-only in practice: copy-memory and template conflicts get a -migrated suffix, skill installs and bootstrap skip any file that's already there and report it, and the strongest operation on your own files is moving a folder aside to a timestamped backup — Claude Code relink (*.backup-<timestamp> in place) and Update Skill… (into ~/.contextzero/backups/<timestamp>/<id>/).
• The one exception: adding an MCP server rewrites that one config file. Copy to… and the MCP Library insert a server into an existing mcp.json/.mcp.json, and JSON can't be appended to — the file is re-serialised in place. Concretely: every other key and every other server in that file is preserved; a server of the same name is never replaced (the write aborts and the file opens instead); the write is atomic — the new content is staged in a sibling temp file and renamed over the target, so an interrupted write leaves the old file intact rather than a truncated one; and no other file in the extension is ever written this way. The one thing not preserved is comments, in the JSONC files that can have them (.vscode/mcp.json) — you're told before and after. ~/.claude.json and ~/.gemini/settings.json are never written at all.
• ~/.contextzero/sources/ is a managed cache, not your files. It holds ContextZero's own clones of git library sources and their search index. ContextZero may delete or re-create anything under it — to recover from a partial clone, or when you use Remove Library Source… — but this is the only location it will ever delete from; nothing outside it is touched.
• Runs git and makes network requests. ContextZero shells out to git to clone and pull library sources (shallow, --filter=blob:none, sparse to the library folders) — daily in the background by default, disable with contextZero.autoUpdateSources: false. Git is only ever invoked with argument arrays (never a shell string), URLs are validated first, credential prompts are disabled outright so a private repo fails instead of hanging, and every invocation is bounded by a timeout.
• Two unprompted network requests, and what they are. On startup ContextZero fetches contextZero.featuredCatalogUrl (suggested skill libraries) and contextZero.mcpCatalogUrl (suggested MCP servers) — two small JSON files — over HTTPS, without asking. Neither sends anything about you or your code: no telemetry, no identifiers, no file contents, just the GET. Each response is capped at 256 KB, redirects that downgrade to plain HTTP are rejected, and any failure is silent (the bundled list is used). Turn the first off with contextZero.showFeaturedLibraries: false or by setting contextZero.featuredCatalogUrl to ""; turn the second off with contextZero.showMcpServers: false or contextZero.mcpCatalogUrl to "". Cloning a repository is the one thing that never happens unprompted — every clone, featured or manual, requires the modal confirmation dialog that names the URL and target folder. Installing an MCP server likewise always shows the confirmation modal naming the exact command/URL and env var names before anything is written.
• Sensitive and binary files invisible. .credentials.json, *.db, *.pb, *.pbtxt, and lock files never appear in the tree or search for any tool, and are never read.
• Confirmation where it matters. Cloning or removing a library source, and Claude Code relink/copy-memory, show a modal dialog first. Install Skill… and Apply to Project… don't confirm — they show a destination picker and skip files that already exist, so there's nothing destructive to confirm.
• Auditable. Every write is logged to the ContextZero output channel (View → Output → ContextZero).

Installation

From the Marketplace — search ContextZero in the Extensions view (Ctrl+Shift+X), or:

ext install TahirNazir.context-zero

or from a terminal:

code --install-extension TahirNazir.context-zero

The ContextZero icon then appears in the activity bar.

_{Marketplace listing: TahirNazir.context-zero}

Building from source

If you'd rather build it yourself:

git clone https://github.com/its-tahir/context-zero.git
cd context-zero
npm install
npm run package                              # builds context-zero-0.3.0.vsix
code --install-extension context-zero-0.3.0.vsix

Without the command line: Ctrl+Shift+P → Extensions: Install from VSIX… → pick the .vsix.

Updating after you change the code

Marketplace installs update themselves. A .vsix you built and installed yourself does not — after editing the source:

npm run compile      # check it builds
npm test             # run the unit tests
npm run package      # rebuild the .vsix
code --install-extension context-zero-0.3.0.vsix   # reinstalls over the old one

Then reload the VS Code window. Tip: bump "version" in package.json when you make real changes, so you can tell which build is installed (code --list-extensions --show-versions).

For development you don't need to install at all: open this folder in VS Code and press F5 — an Extension Development Host window launches with the extension loaded straight from source.

Development

npm run compile      # TypeScript build → out/
npm run watch        # rebuild on save
npm test             # unit tests (vitest) — never touch your real tool homes
npm run test:vscode  # integration smoke test against a fixture home

The tests run against temp directories and a fixture home directory (CONTEXTZERO_HOME override) — your real data is never involved.

Changelog

0.3.0

Team Ops: an MCP Servers section in the Context tree (Global and per project) — read-only, values never shown — with Copy to… for moving a server between tools' configs; a Featured MCP shortlist plus live registry search in the MCP Library; post-install credential reveal; MCP Gaps and Context Gaps rows flagging what's missing across tools; Export Context Pack… for handing a teammate a safe snapshot; empty-state Get started tips; and macOS/Linux Claude Code project matching. See MCP servers, MCP Library, MCP Gaps, Export Context Pack, Context Gaps, and Get started tips below, or CHANGELOG.md for full detail.

0.2.0

Featured libraries in the Templates panel; Update Skill… and diff for skills whose source has moved on; prompt placeholders and Install as Command…; Mirror from… to generate a missing rules file from a sibling; and per-project Context Health. See CHANGELOG.md for detail.

0.1.0

First public release: one sidebar for Claude Code, Cursor, Kiro, Antigravity and AGENTS.md; monorepo nesting; per-project readiness; a prompt and template library; team library sources with A–Z browsing, search and skill installation; project bootstrap; and Claude Code relink/recovery. See CHANGELOG.md for detail.

License

MIT

_{TN. — crafted by Tahir Nazir · its-tahir.com}