contexer 0.1.0__tar.gz

contexer-0.1.0/.claude/commands/bootstrap.md

@@ -0,0 +1,8 @@
+Run a guided context setup for this repo.
+
+1. Call `bootstrap_context` with `repo_path=""` to get inferred facts and gap assumptions.
+2. Present each item one at a time — state what was detected or assumed, then ask "Correct? (yes / no / your correction)". Wait for the reply before moving on.
+3. After each reply, call `update_context` to store the confirmed fact with full reasoning.
+4. When all items are done, confirm how many were stored.
+
+Keep it conversational — no upfront lists, one item per turn.

contexer-0.1.0/.claude/settings.json

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+"mcp__claude_ai_Notion__notion-fetch",
+      "mcp__claude_ai_Notion__notion-search",
+      "mcp__claude_ai_Notion__notion-update-page"
+    ]
+  }
+}

contexer-0.1.0/.claude-plugin/marketplace.json

@@ -0,0 +1,12 @@
+{
+  "name": "contexer",
+  "owner": { "name": "bhargavamin" },
+  "description": "Contexer — MCP context engine for Claude Code",
+  "plugins": [
+    {
+      "name": "contexer",
+      "source": "./",
+      "description": "MCP context engine — persists decisions and constraints across Claude Code sessions"
+    }
+  ]
+}

contexer-0.1.0/.claude-plugin/plugin.json

@@ -0,0 +1,10 @@
+{
+  "name": "contexer",
+  "version": "0.1.0",
+  "description": "MCP context engine — persists decisions and constraints across Claude Code sessions",
+  "author": { "name": "bhargavamin" },
+  "homepage": "https://github.com/bhargavamin/contexer",
+  "repository": "https://github.com/bhargavamin/contexer",
+  "license": "MIT",
+  "keywords": ["mcp", "context", "memory", "claude-code"]
+}

contexer-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,28 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - "v*.*.*"
+
+jobs:
+  build-and-publish:
+    name: Build and publish
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write  # required for OIDC trusted publisher
+      contents: read   # required to checkout private repo
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+
+      - name: Build package
+        run: uv build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

contexer-0.1.0/.gitignore

@@ -0,0 +1,28 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# Test / tool caches
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+
+# IDEs / editors
+.idea/
+.vscode/
+
+# macOS
+.DS_Store
+
+# Claude Code local overrides (project .claude/settings.json is tracked on purpose)
+.claude/settings.local.json
+
+# Dev-only MCP override — plugin handles global registration
+.mcp.json

contexer-0.1.0/.python-version

@@ -0,0 +1 @@
+3.12

contexer-0.1.0/CLAUDE.md

@@ -0,0 +1,65 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Commands
+
+```bash
+# Install dependencies
+uv sync
+
+# Run the server (stdio transport — for manual testing)
+uv run python server.py
+
+# Smoke-test the server responds to MCP initialize
+echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"0"}}}' | uv run python server.py
+```
+
+## Architecture
+
+Three files, no more:
+
+- **`server.py`** — MCP server entry point. Defines five tools (`capture_context`, `update_context`, `get_context`, `get_context_for_prompt`, `bootstrap_context`) using `FastMCP`. Generates a `SESSION_ID` (UUID) at process start shared across all tool calls in a session. Delegates all logic to `store.py`.
+- **`store.py`** — All read/write and filtering logic. `_passes_filter` is the core gate: content is stored only if it is novel (token-overlap check — >70% overlap with existing decisions = duplicate). Storage is capped at `MAX_ENTRIES = 500` per repo. Display is separately capped: `_UNFILTERED_DISPLAY = 10` for overview calls, `_FILTERED_DISPLAY = 25` for query/type-filtered calls.
+- **`requirements.txt`** — Kept for reference; `pyproject.toml` is the authoritative dependency spec managed by `uv`.
+
+## Storage
+
+Context is stored at `~/.contexer/<repo_slug>.json` — one file per repo. The slug is the repo path with non-alphanumeric characters replaced by underscores. Each file holds a flat list of entries, each with `id`, `type` (`task` | `decision`), `subtype` (`architecture` | `constraint` | `pattern` | `convention` — decisions only), `content`, `session_id`, and `timestamp`.
+
+## MCP integration
+
+The server is registered in `~/.claude.json` under `mcpServers`:
+
+```json
+{
+  "contexer": {
+    "type": "stdio",
+    "command": "uv",
+    "args": ["run", "--directory", "/Users/bhargavamin/repos/personal/contexer", "python", "server.py"]
+  }
+}
+```
+
+## Session behaviour (hooks)
+
+`~/.claude/settings.json` wires up hooks globally (applies to every repo):
+
+- **`SessionStart`** — injects all conventions and constraints directly as project rules; injects a count pointer for deferred architecture/pattern decisions (fetched JIT via `get_context`); injects the bootstrap STOP directive if no context exists.
+- **`UserPromptSubmit` (anchor, command, every prompt)** — writes the git root to `~/.contexer/.current_repo` so MCP tools can resolve `repo_path=""` correctly even across concurrent sessions. Runs before all mcp_tool hooks.
+- **`UserPromptSubmit` (bootstrap, mcp_tool, once)** — calls `get_bootstrap_context_prompt` on the first prompt; injects the bootstrap directive if no context exists (fallback for when SessionStart is skipped).
+- **`UserPromptSubmit` (capture, mcp_tool, once)** — calls `capture_context` with the first user prompt as the task description. Stores as `type=task` only — never as a decision or constraint.
+- **`UserPromptSubmit` (rationale, mcp_tool, every prompt)** — calls `get_context_for_prompt` with the prompt text; auto-injects matching decisions when the prompt contains rationale keywords (why, reason, rationale, decided, etc.). Silent no-op for all other prompts.
+- **`PreCompact`** — injects a systemMessage reminding Claude to call `update_context` for any unsaved decisions before the context window is compacted.
+- **`PostCompact`** — re-injects the full context via systemMessage so Claude resumes with full awareness after compaction.
+
+**During a session**, call `update_context` whenever you make a significant decision, establish a pattern, or document a constraint. Pass the full reasoning, not just the conclusion. Optionally pass `subtype` (`architecture` | `constraint` | `pattern` | `convention`) to enable filtered retrieval later. The server filters — if content doesn't meet the novelty criteria it will be silently discarded, so err on the side of calling it.
+
+**Retrieving context JIT**: call `get_context` **before reading files** for any question about architecture, design decisions, rationale, constraints, patterns, or conventions. Fall back to reading files only when context is missing or the question is about current code state (exact syntax, current values). Use `query` for keyword search or `entry_type` to retrieve a specific subtype: `get_context(entry_type="constraint")` returns only constraints (up to 25). Use `limit` to override the display cap. When results are truncated, the output includes a `"showing N of M"` note so you know more exist.
+
+## Design constraints
+
+- **Silent operation is essential.** Tools must not produce noise — `update_context` silently discards filtered content without logging.
+- **No abstraction beyond what exists.** The three-file structure is intentional. Do not add classes, config files, or layers unless the spec changes.
+- **`update_context` is called by Claude Code, not the developer.** Claude Code nominates content; the server filters. The filtering criterion is novelty — >70% token overlap with any existing decision is rejected as a duplicate, not an LLM call.
+- **Git hooks and CLI commits are out of scope.** The MCP tool call path is the only capture mechanism.

contexer-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bhargav Amin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

contexer-0.1.0/PKG-INFO

@@ -0,0 +1,207 @@
+Metadata-Version: 2.4
+Name: contexer
+Version: 0.1.0
+Summary: MCP server that captures and retrieves architectural decisions and context for Claude Code sessions
+Project-URL: Homepage, https://github.com/bhargavamin/contexer
+Project-URL: Repository, https://github.com/bhargavamin/contexer
+Project-URL: Issues, https://github.com/bhargavamin/contexer/issues
+Author-email: Bhargav Amin <devops.techpro@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: ai,claude,context,decisions,llm,mcp
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Requires-Dist: mcp>=1.9.4
+Description-Content-Type: text/markdown
+
+# Contexer
+
+Contexer is a lightweight MCP server for Claude Code that automatically captures decisions made during coding sessions and surfaces them at the start of every future session — so Claude never starts blind.
+
+## The problem
+
+Every Claude Code session starts with no memory of the previous one. CLAUDE.md files require manual maintenance and go stale. When Claude works autonomously, the reasoning behind decisions disappears when the session ends. Teams end up re-explaining the same constraints, conventions, and architecture choices every time.
+
+Contexer solves this by capturing decisions as they happen — silently, automatically, in the background — and replaying them as project rules at session start.
+
+---
+
+## Quick start
+
+Install takes under two minutes. See **[docs/install.md](docs/install.md)** for full steps, verification, and uninstall.
+For hooks, tool internals, filter logic, and storage layout see **[docs/architecture.md](docs/architecture.md)**.
+
+**Plugin (recommended):**
+
+```
+/plugin marketplace add bhargavamin/contexer
+/plugin install contexer@contexer
+/reload-plugins
+```
+
+**Manual:**
+
+```bash
+git clone git@github.com:bhargavamin/contexer.git ~/tools/contexer
+bash ~/tools/contexer/scripts/install.sh
+```
+
+After install, **open a new Claude Code session in any repo.** If no context exists, Claude will automatically run a bootstrap to capture your first decisions. If context exists, all constraints and conventions are injected at session start.
+
+---
+
+## How it works
+
+You work normally. Contexer runs in the background via Claude Code hooks.
+
+```
+Session opens
+  └─▶ All conventions + constraints injected as project rules
+      Architecture/pattern decisions available on demand (JIT)
+      First session with no context → bootstrap runs automatically
+
+You type a prompt
+  └─▶ Your first message is stored as the current task description
+  └─▶ "Why/reason/rationale/decided" questions auto-fetch matching decisions
+
+Claude works
+  └─▶ Calls get_context when it needs architecture or pattern context
+  └─▶ Calls update_context when it makes a significant decision
+
+Context window nears limit
+  └─▶ Claude is reminded to save any unsaved decisions before compaction
+  └─▶ After compaction, full context is reloaded automatically
+```
+
+**You never call any tool directly.** Claude handles all tool calls. If Claude misses something, say *"store that decision"* and it will call `update_context` immediately.
+
+---
+
+## Decision types
+
+Every stored decision has a `subtype` that controls when and how it is surfaced.
+
+| Subtype | What it captures | Injected at session start? |
+|---|---|---|
+| `constraint` | Rules that must always apply — "never commit untested code" | Yes — always |
+| `convention` | Team or project standards — "use uv not pip", "conventional commits" | Yes — always |
+| `architecture` | Structural decisions — "chose FastMCP over low-level mcp.Server" | No — fetched on demand |
+| `pattern` | Recurring implementation approaches — "plain dicts as function boundaries" | No — fetched on demand |
+
+Constraints and conventions are injected directly at every session start because they apply to every task. Architecture and pattern decisions are large and task-specific — Claude fetches them just-in-time when the task requires them.
+
+---
+
+## Managing decisions
+
+All operations use natural language. Claude translates them into the right tool call.
+
+### Store a decision
+
+```
+"store that as a constraint"
+"save this as a convention: always use uv not pip"
+"remember this architecture decision"
+```
+
+Claude calls `update_context` with the content and the appropriate subtype. The server applies a novelty filter before storing — content with more than 70% token overlap with an existing decision is silently discarded as a duplicate.
+
+> **Note:** Your first prompt each session is automatically stored as the *task description* — not as a decision or constraint. If you open a session with an instruction like *"always update docs before committing"*, it is captured as the task, not stored as a constraint. To store it as a constraint, either complete the turn (Claude will call `update_context` at the end) or explicitly say *"store that as a constraint"*.
+
+### Query decisions
+
+```
+"show me all constraints"
+"what decisions did we make about postgres?"
+"show everything stored for this repo"
+```
+
+| Example call | What it returns |
+|---|---|
+| `get_context()` | Latest 10 decisions — overview |
+| `get_context(entry_type="constraint")` | Up to 25 constraints |
+| `get_context(query="postgres")` | Up to 25 decisions matching "postgres" |
+| `get_context(limit=50)` | Up to 50 decisions |
+
+### Update a decision
+
+```
+"update the uv decision — we switched back to pip"
+"correct the constraint about commit format"
+```
+
+Claude calls `update_context` with the revised content. The old entry is not removed — a new entry is added alongside it. If the revised content is too similar to the original (>70% token overlap), it will be filtered as a duplicate. Rephrase it to include what changed.
+
+### Remove a decision
+
+```
+"delete the postgres decision"
+"remove all outdated constraints"
+```
+
+Claude reads `~/.contexer/<repo_slug>.json` and removes the matching entry directly. The file is plain JSON — you can also edit or prune it manually at any time.
+
+---
+
+## Tools reference
+
+| Tool | Triggered by | What it does |
+|---|---|---|
+| `capture_context` | `UserPromptSubmit` hook — once per session | Stores the first prompt as the task description |
+| `update_context` | Claude, mid-task | Nominates a decision; server filters before storing |
+| `get_context` | Claude, on demand | Returns stored decisions — filtered by keyword or subtype |
+| `get_context_for_prompt` | `UserPromptSubmit` hook — every prompt | Detects rationale questions and auto-injects matching decisions |
+| `bootstrap_context` | Claude, first session with no context | Scans repo stack for inferable decisions; surfaces gap questions |
+
+---
+
+## Storage
+
+Decisions are stored locally at `~/.contexer/<repo_slug>.json` — one file per repo, capped at 500 entries. No cloud, no database, no accounts.
+
+Each entry contains:
+
+| Field | Values |
+|---|---|
+| `id` | UUID |
+| `type` | `task` or `decision` |
+| `subtype` | `architecture` \| `constraint` \| `pattern` \| `convention` |
+| `content` | The full decision text |
+| `session_id` | UUID for the session that created it |
+| `timestamp` | ISO 8601 UTC |
+
+Inspect the store at any time:
+
+```bash
+cat ~/.contexer/<repo_slug>.json
+```
+
+---
+
+## Troubleshooting
+
+**Claude isn't storing decisions automatically.**
+Claude calls `update_context` at the end of significant decisions, not continuously. If something specific was missed, say *"store that decision"* and Claude will call it immediately.
+
+**A decision was stored but later ignored.**
+Constraints and conventions are injected at session start. If you added a new constraint mid-session, it will appear from the next session onward.
+
+**A decision is outdated or wrong.**
+Say *"delete the X decision"* or edit `~/.contexer/<repo_slug>.json` directly and remove the entry.
+
+**The novelty filter rejected a new decision.**
+If the content is too similar to an existing one (>70% token overlap), it is silently discarded. Rephrase it to be more specific, or remove the old entry first.
+
+**No context was injected at session start.**
+If no decisions are stored for the repo, the bootstrap flow runs instead. Complete bootstrap once and all future sessions will have context.
+
+---
+
+## License
+
+MIT

contexer-0.1.0/README.md

@@ -0,0 +1,186 @@
+# Contexer
+
+Contexer is a lightweight MCP server for Claude Code that automatically captures decisions made during coding sessions and surfaces them at the start of every future session — so Claude never starts blind.
+
+## The problem
+
+Every Claude Code session starts with no memory of the previous one. CLAUDE.md files require manual maintenance and go stale. When Claude works autonomously, the reasoning behind decisions disappears when the session ends. Teams end up re-explaining the same constraints, conventions, and architecture choices every time.
+
+Contexer solves this by capturing decisions as they happen — silently, automatically, in the background — and replaying them as project rules at session start.
+
+---
+
+## Quick start
+
+Install takes under two minutes. See **[docs/install.md](docs/install.md)** for full steps, verification, and uninstall.
+For hooks, tool internals, filter logic, and storage layout see **[docs/architecture.md](docs/architecture.md)**.
+
+**Plugin (recommended):**
+
+```
+/plugin marketplace add bhargavamin/contexer
+/plugin install contexer@contexer
+/reload-plugins
+```
+
+**Manual:**
+
+```bash
+git clone git@github.com:bhargavamin/contexer.git ~/tools/contexer
+bash ~/tools/contexer/scripts/install.sh
+```
+
+After install, **open a new Claude Code session in any repo.** If no context exists, Claude will automatically run a bootstrap to capture your first decisions. If context exists, all constraints and conventions are injected at session start.
+
+---
+
+## How it works
+
+You work normally. Contexer runs in the background via Claude Code hooks.
+
+```
+Session opens
+  └─▶ All conventions + constraints injected as project rules
+      Architecture/pattern decisions available on demand (JIT)
+      First session with no context → bootstrap runs automatically
+
+You type a prompt
+  └─▶ Your first message is stored as the current task description
+  └─▶ "Why/reason/rationale/decided" questions auto-fetch matching decisions
+
+Claude works
+  └─▶ Calls get_context when it needs architecture or pattern context
+  └─▶ Calls update_context when it makes a significant decision
+
+Context window nears limit
+  └─▶ Claude is reminded to save any unsaved decisions before compaction
+  └─▶ After compaction, full context is reloaded automatically
+```
+
+**You never call any tool directly.** Claude handles all tool calls. If Claude misses something, say *"store that decision"* and it will call `update_context` immediately.
+
+---
+
+## Decision types
+
+Every stored decision has a `subtype` that controls when and how it is surfaced.
+
+| Subtype | What it captures | Injected at session start? |
+|---|---|---|
+| `constraint` | Rules that must always apply — "never commit untested code" | Yes — always |
+| `convention` | Team or project standards — "use uv not pip", "conventional commits" | Yes — always |
+| `architecture` | Structural decisions — "chose FastMCP over low-level mcp.Server" | No — fetched on demand |
+| `pattern` | Recurring implementation approaches — "plain dicts as function boundaries" | No — fetched on demand |
+
+Constraints and conventions are injected directly at every session start because they apply to every task. Architecture and pattern decisions are large and task-specific — Claude fetches them just-in-time when the task requires them.
+
+---
+
+## Managing decisions
+
+All operations use natural language. Claude translates them into the right tool call.
+
+### Store a decision
+
+```
+"store that as a constraint"
+"save this as a convention: always use uv not pip"
+"remember this architecture decision"
+```
+
+Claude calls `update_context` with the content and the appropriate subtype. The server applies a novelty filter before storing — content with more than 70% token overlap with an existing decision is silently discarded as a duplicate.
+
+> **Note:** Your first prompt each session is automatically stored as the *task description* — not as a decision or constraint. If you open a session with an instruction like *"always update docs before committing"*, it is captured as the task, not stored as a constraint. To store it as a constraint, either complete the turn (Claude will call `update_context` at the end) or explicitly say *"store that as a constraint"*.
+
+### Query decisions
+
+```
+"show me all constraints"
+"what decisions did we make about postgres?"
+"show everything stored for this repo"
+```
+
+| Example call | What it returns |
+|---|---|
+| `get_context()` | Latest 10 decisions — overview |
+| `get_context(entry_type="constraint")` | Up to 25 constraints |
+| `get_context(query="postgres")` | Up to 25 decisions matching "postgres" |
+| `get_context(limit=50)` | Up to 50 decisions |
+
+### Update a decision
+
+```
+"update the uv decision — we switched back to pip"
+"correct the constraint about commit format"
+```
+
+Claude calls `update_context` with the revised content. The old entry is not removed — a new entry is added alongside it. If the revised content is too similar to the original (>70% token overlap), it will be filtered as a duplicate. Rephrase it to include what changed.
+
+### Remove a decision
+
+```
+"delete the postgres decision"
+"remove all outdated constraints"
+```
+
+Claude reads `~/.contexer/<repo_slug>.json` and removes the matching entry directly. The file is plain JSON — you can also edit or prune it manually at any time.
+
+---
+
+## Tools reference
+
+| Tool | Triggered by | What it does |
+|---|---|---|
+| `capture_context` | `UserPromptSubmit` hook — once per session | Stores the first prompt as the task description |
+| `update_context` | Claude, mid-task | Nominates a decision; server filters before storing |
+| `get_context` | Claude, on demand | Returns stored decisions — filtered by keyword or subtype |
+| `get_context_for_prompt` | `UserPromptSubmit` hook — every prompt | Detects rationale questions and auto-injects matching decisions |
+| `bootstrap_context` | Claude, first session with no context | Scans repo stack for inferable decisions; surfaces gap questions |
+
+---
+
+## Storage
+
+Decisions are stored locally at `~/.contexer/<repo_slug>.json` — one file per repo, capped at 500 entries. No cloud, no database, no accounts.
+
+Each entry contains:
+
+| Field | Values |
+|---|---|
+| `id` | UUID |
+| `type` | `task` or `decision` |
+| `subtype` | `architecture` \| `constraint` \| `pattern` \| `convention` |
+| `content` | The full decision text |
+| `session_id` | UUID for the session that created it |
+| `timestamp` | ISO 8601 UTC |
+
+Inspect the store at any time:
+
+```bash
+cat ~/.contexer/<repo_slug>.json
+```
+
+---
+
+## Troubleshooting
+
+**Claude isn't storing decisions automatically.**
+Claude calls `update_context` at the end of significant decisions, not continuously. If something specific was missed, say *"store that decision"* and Claude will call it immediately.
+
+**A decision was stored but later ignored.**
+Constraints and conventions are injected at session start. If you added a new constraint mid-session, it will appear from the next session onward.
+
+**A decision is outdated or wrong.**
+Say *"delete the X decision"* or edit `~/.contexer/<repo_slug>.json` directly and remove the entry.
+
+**The novelty filter rejected a new decision.**
+If the content is too similar to an existing one (>70% token overlap), it is silently discarded. Rephrase it to be more specific, or remove the old entry first.
+
+**No context was injected at session start.**
+If no decisions are stored for the repo, the bootstrap flow runs instead. Complete bootstrap once and all future sessions will have context.
+
+---
+
+## License
+
+MIT

contexer-0.1.0/contexer/__main__.py

@@ -0,0 +1,3 @@
+from contexer.server import main
+
+main()

contexer-0.1.0/contexer/server.py

@@ -0,0 +1,78 @@
+import json
+import uuid
+from mcp.server.fastmcp import FastMCP
+from contexer import store
+
+SESSION_ID = str(uuid.uuid4())
+mcp = FastMCP("contexer")
+
+
+@mcp.tool()
+def capture_context(description: str, repo_path: str = "") -> str:
+    """Called at the start of every task. Captures the developer's task description for the given repo."""
+    resolved = store._resolve_repo(repo_path)
+    if not resolved:
+        return "Skipped — repo path not detected."
+    entry_id = store.capture_task(resolved, description, SESSION_ID)
+    if entry_id is None:
+        return "Skipped — does not look like a task description."
+    return f"Captured. id={entry_id}"
+
+
+@mcp.tool()
+def update_context(content: str, repo_path: str = "", subtype: str = "") -> str:
+    """Called when Claude Code makes a significant decision mid-task. The server filters before storing.
+
+    subtype: optional classification for filtered retrieval — architecture | constraint | pattern | convention
+    """
+    resolved = store._resolve_repo(repo_path)
+    if not resolved:
+        return "Skipped — repo path not detected."
+    stored, entry_id = store.update_decision(resolved, content, SESSION_ID, subtype)
+    if stored:
+        return f"Stored. id={entry_id}"
+    return "Filtered — did not meet storage criteria."
+
+
+@mcp.tool()
+def get_context(repo_path: str = "", query: str = "", entry_type: str = "", limit: int = 0) -> str:
+    """Returns stored context for the current repository. Call this when the task requires project context.
+
+    query: optional keyword filter (case-insensitive substring match against decision content).
+    entry_type: optional subtype filter — architecture | constraint | pattern | convention
+    limit: max decisions to return (0 = auto: 25 for filtered queries, 10 for unfiltered overview).
+    """
+    resolved = store._resolve_repo(repo_path)
+    if not resolved:
+        return "No repo path detected."
+    return store.get_context(resolved, query, entry_type, limit)
+
+
+@mcp.tool()
+def bootstrap_context(repo_path: str = "") -> str:
+    """Scans a repo for inferable decisions and gap questions. Present inferred
+    items to the user for confirmation, store confirmed ones via update_context,
+    then ask the gap questions and store each answer."""
+    resolved = store._resolve_repo(repo_path)
+    if not resolved:
+        return json.dumps({"error": "repo path not detected"})
+    return json.dumps(store.bootstrap_scan(resolved), indent=2)
+
+
+@mcp.tool()
+def get_context_for_prompt(repo_path: str = "", prompt: str = "") -> str:
+    """Auto-called by UserPromptSubmit hook on every prompt. Detects rationale/decision
+    questions (why, reason, rationale, decided...) and injects matching stored decisions
+    as additionalContext. Returns empty string for non-rationale prompts — silent no-op."""
+    resolved = store._resolve_repo(repo_path)
+    if not resolved:
+        return ""
+    return store.get_context_for_prompt(resolved, prompt)
+
+
+def main():
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()