contextkit - AI Context Engine

Generate AI context (rules + docs + conventions) from your codebase for Cursor, Claude Code, GitHub Copilot, and Continue.dev.

Stop maintaining 4 different rule files. Stop wasting tokens re-reading the same code. Let contextkit automatically extract your project's knowledge and export it to every AI coding tool your team uses.

🎯 The Problem

Your team uses multiple AI coding tools:

• 🟦 Cursor (.cursorrules)
• 🟧 Claude Code (CLAUDE.md)
• 🟪 GitHub Copilot (copilot-instructions.md)
• 🟩 Continue.dev (.continue/rules/)

Every time someone joins or a new tool is adopted, rules get duplicated, drift apart, or disappear. Meanwhile, every developer keeps feeding the same codebase to the AI — burning tokens on every prompt.

✨ The Solution

$ cd my-project
$ contextkit init .

🔍 Analyzing codebase...
📝 Extracted 14 coding rules
📚 Generated 6 doc sections
💾 Exported to 4 formats

✨ Done! Token savings: 71.3% (4,487 → 1,288 tokens)

One command. Four formats. Zero duplication.

🚀 Quick Start

Install

pip install contextkit

Use

# Analyze and generate context
contextkit init .

# Watch for changes and auto-regenerate
contextkit watch .

# Validate existing context files
contextkit validate .

# Compare with last snapshot
contextkit diff .ai-context

# Health check + auto-fix
contextkit doctor . --fix

# Merge multiple rule files
contextkit merge .cursorrules CLAUDE.md --output merged.md

# Generate a config file
contextkit config

# Create team plugins
contextkit plugin create team-standards

# Set up CI/CD
contextkit hook pre-commit
contextkit hook github-action

📦 What Gets Generated

By default, contextkit creates a .ai-context/ directory with:

.ai-context/
├── cursor/
│   ├── .cursorrules              # Single-file format
│   └── .cursor/rules/            # Modular format (newer Cursor)
│       ├── 00-project.md
│       ├── 01-tech-stack.md
│       ├── 02-conventions.md
│       └── 03-architecture.md
├── claude/
│   ├── CLAUDE.md                 # For Claude Code
│   └── API.md                    # (if API routes detected)
├── copilot/
│   └── .github/
│       └── copilot-instructions.md
└── continue/
    └── .continue/rules/
        ├── project.md
        ├── style.md
        ├── naming.md
        ├── architecture.md
        ├── error_handling.md
        ├── testing.md
        ├── imports.md
        └── documentation.md

🎨 Use Cases

1. Onboarding new team members

# New dev clones the repo
git clone ...
contextkit init .
# Now their AI assistant "knows" the codebase from day 1

2. Migrating to a new AI tool

# Team switches from Cursor to Claude Code
contextkit init . --formats claude
cp .ai-context/claude/CLAUDE.md .
# All coding rules transferred automatically

3. Heterogeneous teams

# Half uses Cursor, half uses Claude Code
contextkit init . --formats cursor,claude,copilot
# Everyone gets the same context

4. Cost optimization

contextkit estimate .
# → Token savings: 71%
# → Monthly savings (10 devs): $106

🔧 How It Works

┌──────────────────────────────────────────────┐
│         YOUR CODEBASE                        │
│  (Python, JS/TS, Go, Rust, etc.)             │
└──────────────────┬───────────────────────────┘
                   │
        ┌──────────▼──────────┐
        │  1. ANALYZER        │  → Detects languages, frameworks,
        │                     │    lint/format configs, structure
        └──────────┬──────────┘
                   │
        ┌──────────▼──────────┐
        │  2. RULE EXTRACTOR  │  → Heuristics + optional LLM
        │                     │    (naming, style, error handling...)
        └──────────┬──────────┘
                   │
        ┌──────────▼──────────┐
        │  3. DOC GENERATOR   │  → Auto-generates architecture,
        │                     │    setup, API surface docs
        └──────────┬──────────┘
                   │
        ┌──────────▼──────────┐
        │  4. MULTI-FORMAT    │  → Exports to .cursorrules,
        │     EXPORTER        │    CLAUDE.md, copilot, continue
        └─────────────────────┘

🧠 What Gets Extracted

Coding Rules (auto-detected)

• ✅ Naming conventions (snake_case, camelCase, etc.)
• ✅ Linters/formatters (Black, Ruff, Prettier, ESLint, etc.)
• ✅ Framework conventions (FastAPI async/await, React hooks, Go naming)
• ✅ Error handling patterns (HTTPException, Result types, etc.)
• ✅ Testing rules (pytest fixtures, Jest patterns)
• ✅ Import organization (isort, absolute imports)
• ✅ Documentation standards (docstrings, JSDoc)

Documentation (auto-generated)

• ✅ Project overview (from README + pyproject.toml + package.json)
• ✅ Architecture (structure type, entry points, key components)
• ✅ Tech stack (languages, frameworks, tooling)
• ✅ Setup instructions (package manager-aware)
• ✅ API surface (detected from FastAPI/Express routes)

📊 Real-World Results

Tested on 3 sample projects:

Project	Language	Rules	Token Savings
FastAPI Task Manager	Python	14	71.3%
Next.js E-commerce	TypeScript	10	34.8%
Go URL Shortener	Go	2	81.7%

🎛️ Configuration

CLI Options

contextkit init [PATH] [OPTIONS]

Options:
  -o, --output DIR       Output directory (default: .ai-context)
  -f, --formats LIST     Comma-separated: cursor,claude,copilot,continue
  --no-llm              Skip LLM analysis (faster, no API key needed)
  --llm-model MODEL     LLM model (default: claude-sonnet-4-5)
  -n, --name NAME       Override project name
  -v, --verbose         Verbose output

Environment Variables

• ANTHROPIC_API_KEY — Required for LLM-powered rule extraction (optional)

🤖 LLM-Enhanced Mode

By default, contextkit uses heuristics (regex, AST analysis, config detection) to extract rules. This is fast, deterministic, and works offline.

For deeper insights, set ANTHROPIC_API_KEY and contextkit will additionally call Claude to extract:

• Architecture patterns specific to your codebase
• Non-obvious conventions
• Domain-specific rules

The heuristics run first, then LLM-extracted rules are merged in. If the LLM call fails, the heuristics still work.

🆚 Comparison

Feature	contextkit	Cursor	Mintlify	Greptile
Auto-generate from code	✅	❌	❌	⚠️
Multi-tool export	✅	❌	❌	❌
Open source	✅	❌	❌	❌
Self-hosted	✅	❌	❌	⚠️
Token optimization	✅	❌	N/A	❌
Code + Docs unified	✅	❌	⚠️	❌
Watch mode	✅	❌	❌	❌
Validation	✅	❌	❌	❌
Snapshot diff	✅	❌	❌	❌
Config file	✅	⚠️	❌	❌
Plugin system	✅	❌	❌	❌
CI/CD hooks	✅	❌	❌	❌
Multi-source merge	✅	❌	❌	❌
Health diagnostics	✅	❌	❌	❌
Free	✅	⚠️	⚠️	❌

🗺️ Roadmap

• v0.1 — MVP with heuristic extraction + multi-format export
• v0.2 — Config file, validate, diff, watch, Java/C# support
• v0.3 — Plugin system, hooks, doctor, merge
• v0.4 — Web dashboard for team management
• v0.5 — VS Code extension
• v0.6 — Real-time context updates via webhooks
• v1.0 — Team centralization (SSO, audit, RBAC)

🛠️ Development

# Clone
git clone https://github.com/itsurge/contextkit
cd contextkit

# Install in editable mode
pip install -e ".[dev]"

# Test on sample repos
cd ../test-repos/fastapi-sample
contextkit init . --no-llm

🤝 Contributing

We welcome PRs! Especially:

• 🌐 More language support (Rust, Java, C#, Ruby)
• 🧠 Smarter rule extraction
• 📦 New export formats
• 🐛 Bug fixes
• 📚 Documentation

📄 License

MIT — see LICENSE

🌟 Why This Project Exists

The AI coding revolution is happening, but most teams are stuck in a messy reality:

• Multiple AI tools in use
• Outdated or missing rule files
• Wasted tokens re-reading the same code
• No standardization

contextkit fixes this with a single command that works for every tool.

---

Built with ❤️ by developers who got tired of writing the same .cursorrules four times.