Contextpoint

Your project's memory for AI coding sessions.

The problem it solves

You open a fresh Claude chat and type the same paragraph again: what you're building, which files matter, what the model must not touch, which approach already failed on Tuesday. Contextpoint keeps that paragraph for you, per project, and delivers it in one click.

It starts before you type anything. Open a git repo and Contextpoint reads your latest commit to name the task.

How you use it

1. Open a project in VS Code and click the Contextpoint icon in the activity bar
2. Accept the task Contextpoint detected from your last commit, or click it and rename it
3. Add constraints (rules Claude must not break) and failed attempts (dead ends you already hit)
4. Press send or Ctrl+Alt+S

Contextpoint compiles your task, constraints, failed attempts, notes, branch, changed files, and open editors into a short prompt, then hands it to Claude.

Where the prompt goes

You pick once on first send. Change it any time with Contextpoint: Change AI Provider.

• Claude Code, opened in your project folder
• Claude desktop app
• claude.ai in your browser
• Anthropic API, with the reply shown inside VS Code

The first three ride on your Claude subscription. Only the API path asks for a key.

Claude Code works the context itself (MCP)

Contextpoint ships an MCP server, so Claude Code reads and updates your context without any copying.

Run Contextpoint: Connect Claude Code (MCP) once. It writes a project-scoped .mcp.json, keeps any other MCP servers you have configured, and points Claude Code at a version-stable launcher, so the connection survives extension updates. Restart Claude Code and it can call:

Tool	What Claude does with it
get_context	Reads the compiled context. If nothing changed since the last call, the server answers with one line instead of the full prompt. force:true overrides; max_tokens trims to a budget.
get_changes_since_checkpoint	Catches up after a break: commits and files since the last snapshot, plus a warning when you're on a different branch than the snapshot.
start_task / complete_task	Begins or finishes a task from inside Claude Code.
add_constraint, add_note, add_failed_attempt, add_non_goal	Writes context back mid-session. The server spots near-duplicates and skips them.
add_important_file	Marks a file as central to the task.
remove_item	Prunes context that no longer applies, so it stops costing tokens in future prompts.
save_checkpoint	Snapshots progress with branch and commit.
set_task_status	Sets active, paused, or done.
get_state	Reads the raw state as JSON.

Contextpoint is not on npm, so an npx contextpoint entry in .mcp.json fails. Use the one-click command; it wires the correct path. If Claude Code launches the server from a subdirectory, the server walks up and finds your project state on its own.

Token accounting

Each compile shows an estimated token count. The sidebar keeps a per-project ledger: tokens sent, and tokens you skipped re-typing because the context was already saved. On the API path, real usage numbers from Anthropic calibrate the estimator.

Lockfiles and build output (package-lock.json, dist/, minified bundles) collapse into a single line in the changed-files list. This keeps a model from spending 20k tokens reading a lockfile it never needed.

Want a hard ceiling? Set contextpoint.maxPromptTokens. Contextpoint trims notes and file lists first, marks what it cut, and leaves your task, constraints, and failed attempts intact.

CLAUDE.md, maintained without clobbering yours

Contextpoint maintains a managed block, fenced by <!-- contextpoint:begin --> markers, inside your project's CLAUDE.md. Claude Code loads that file at the start of each session, so your context arrives before you type. If you hand-wrote a CLAUDE.md, Contextpoint appends its block and updates it in place, leaving the rest of the file untouched. Writes go through a temp file and rename, so Claude can't read a half-written file. Contextpoint caps the lists, so the file stays small.

A progress journal with no typing

Each git commit records a snapshot, with the commit message as the summary. Turn it off with contextpoint.autoSnapshotOnCommit. Paired with get_changes_since_checkpoint, your next session starts from a recorded trail of commits and snapshots.

Contextpoint catches branch changes

Switch branches and Contextpoint warns you that your saved context describes the old one, then offers a snapshot. This works in plain clones, git worktrees, and submodules.

Privacy

Contextpoint runs entirely on your machine. It reads your repo locally and compiles a prompt you can see before it goes anywhere. It needs no account, no backend, and no telemetry. If you use an API key, VS Code's secret storage holds it.

Install

Search Contextpoint in the VS Code Marketplace, or install the .vsix:

code --install-extension contextpoint-1.1.0.vsix

Commands

From the panel or Ctrl+Shift+P:

Command
Contextpoint: Send to Claude	Ctrl+Alt+S / Cmd+Alt+S
Contextpoint: Compile Prompt
Contextpoint: Start New Task
Contextpoint: Rename Task
Contextpoint: Add Constraint
Contextpoint: Add Note
Contextpoint: Add Failed Attempt
Contextpoint: Save Snapshot
Contextpoint: Connect Claude Code (MCP)
Contextpoint: Change AI Provider
Contextpoint: Set Anthropic API Key
Contextpoint: Reset AI Settings
Contextpoint: How It Works

Where your data lives

State sits in .contextpoint/state.json at your project root. Add .contextpoint/ to .gitignore; it's per-machine state.

CLAUDE.md lands in the project root too. Commit that one if you want your team to share the context.

Development

npm install
npm test     # 305 assertions across 12 suites
npm run build

License

MIT

---

Built by Maksym Gavrylenko at Valten Studio