CLI tool for instant Claude Code project scaffolding with context engineering best practices
Transform your project ideas into AI-ready applications with intelligent context engineering
🎯 Optimized for Claude Code with deep integration for slash commands, hooks, and PRPs
Also supports Cursor, Windsurf, Cline, Copilot, Gemini, and more AI coding assistants
|
NEW: Safely transition between technology stacks!
context-forge migrate --target "Next.js"
|
Pause for verification at critical milestones Never lose control during AI development!
/checkpoint "Database migration complete"
|
|
Comprehensive command library:
|
|
|
|
|
Product Requirement Prompts (PRP) now available for Claude, Cursor, Windsurf, Cline, Copilot & Gemini!
Structured feature implementation with validation gates across all major AI coding assistants!
Context Forge is a powerful CLI tool that bridges the gap between project requirements and AI-assisted development. By implementing Andre Karpathy's context engineering principles, it generates comprehensive documentation structures that enable AI IDEs to understand and build your project efficiently—without hallucinations or context confusion.
🌐 Universal AI IDE Support - Works with ALL major AI coding assistants
⚡ Zero Configuration - Intelligent defaults for each IDE
🎯 One Command - Generate configs for multiple IDEs simultaneously
🔄 Format Conversion - Switch between IDEs without starting over
🔗 Claude Hooks Integration - Seamless context preservation during compaction
📦 No Lock-in - Your project, your choice of AI assistant
 Claude Code Full PRP support |
 Cursor IDE PRP + MDC format |
 Windsurf PRP + Cascade AI |
|
 Cline PRP + Context mgmt |
 Roo Code Hierarchical rules |
 Gemini PRP + CLI & Code Assist |
 GitHub Copilot Custom instructions |
Coming Soon: Amazon CodeWhisperer, Tabnine, and more!
Need help understanding how each IDE uses its configuration? Check out our detailed guides:
- 🤖 Claude Code Guide - Full PRP support, validation system, tech-stack templates
- 🔵 Cursor IDE Guide - PRP support, MDC format, hierarchical rules
- 🟩 Windsurf Guide - PRP support, Cascade AI integration, workflows
- 🟢 Cline Guide - PRP support, context management, code patterns, advanced commands
- 🟣 Roo Code Guide - Workspace rules, YAML configuration, team settings
- 🟠 Gemini Guide - PRP support, hierarchical context, CLI commands, Code Assist integration
- ⚫ GitHub Copilot Guide - Custom instructions, VS Code settings, language-specific rules
📚 Complete Claude Features Guide - Master the new advanced features:
- ⚡ Slash Commands Reference - 20+ pre-built commands for rapid development
- 🤖 PRP Runner Guide - Automated PRP execution with validation gates
- 📝 Enhanced PRP Templates - Four specialized templates for different scenarios
- 🎯 Orchestration Workflow - How all components work together
- 🚀 No AI Dependencies - Works completely offline without API keys
- 🤖 Multi-IDE Support - Generate configs for multiple AI IDEs at once
- 📋 Interactive CLI - Guided project setup with IDE selection
- 🎯 Template-based Generation - IDE-specific documentation formats
- 🛠️ Multiple Tech Stacks - Support for 9+ frameworks with specific configurations
- 📁 Structured Output - Organized documentation following each IDE's conventions
- ⚡ Fast Setup - Go from zero to AI-ready project in minutes
- 🔄 Technology Migration - Safe migration planning between tech stacks
- 🔧 Retrofit Existing Projects - Analyze and upgrade existing codebases with AI documentation
- 🔍 PRP Integration - Product Requirement Prompts with validation loops (Claude, Cursor, Windsurf, Cline, Copilot & Gemini)
- ✅ Validation System - Built-in code quality checks and gates
- 🛑 Human-in-the-Loop Checkpoints - Pause for verification at critical milestones
- 🪝 Claude Code Hooks - PreCompact, ContextRotation, PreSubmit, and PRPTracking hooks
- ⚡ 20+ Slash Commands - Comprehensive command library for rapid development
- 🎨 Tech-Stack Specific Templates - Optimized CLAUDE.md for each framework
- 📊 Comprehensive Reporting - Validation reports and progress tracking
- 🔄 Phased Migration Plans - Step-by-step migration with rollback strategies
- 🔧 Extensible Architecture - Easy to add new tech stacks and features
Context Forge provides deep integration with Claude Hooks Manager through 4 powerful hooks that enhance your development workflow and maintain context throughout long sessions.
With Claude Code v1.0.48+, the PreCompact hook ensures your PRPs and project context survive conversation compaction:
- 🧠 Critical project structure persists
- 🎯 Current implementation stage maintained
- 📋 Validation gates remain active
Intelligently manages which files stay in context as you work:
- 📁 Prioritizes relevant files based on current task
- 🔄 Automatically rotates less relevant files out
- 💾 Preserves critical configuration files
Runs validation before code submission:
- ✅ Syntax and type checking
- 🧪 Test execution
- 📊 Coverage requirements
- 🔒 Security scanning
Tracks PRP implementation progress:
- 📈 Monitors task completion
- ⏱️ Time tracking per feature
- 📋 Automatic status updates
- 🎯 Milestone achievements
# Generate project with hooks
context-forge init # Select "Enable Claude Code hooks? Yes"
# Or copy hooks from another project
context-forge copy-hooks --source ../claude-hooks-repo/hooks
# Hooks are created in:
# .claude/hooks/This integration is especially powerful for:
- Long-running development sessions
- Complex multi-phase implementations
- Team projects requiring consistency
- Migration projects with checkpoints
Context Forge introduces a powerful checkpoint system that pauses AI development at critical milestones for human verification, ensuring you maintain control over the implementation process.
- Prevent Breaking Changes: Verify database migrations before data modification
- Quality Assurance: Review architectural decisions before proceeding
- Safety First: Human approval for production deployments
- Learning Opportunity: Understand what the AI has implemented
- Automatic Triggers: AI pauses at predefined critical points
- Manual Checkpoints: Use
/checkpointcommand anytime - Verification Request: AI presents what was done and what needs testing
- Human Decision: Approve to continue or request fixes
/checkpoint [description]- Create manual checkpoint/should-checkpoint- AI asks if checkpoint is needed/milestone-gate [milestone]- Major milestone verification
🛑 CHECKPOINT: Human Verification Required
Analytics Dashboard - I've completed database schema setup:
✅ What I've Accomplished:
- Created PostgreSQL schema with 5 tables
- Set up foreign key relationships
- Added indexes for query optimization
🧪 Please Test:
1. Run: npm run db:migrate
2. Check tables exist: psql -c "\dt"
3. Verify foreign keys: psql -c "\d+ users"
📋 Critical Verification Points:
- [ ] All tables created successfully
- [ ] Foreign keys properly linked
- [ ] No data loss from existing tables
Please respond:
- ✅ "Approved" - Continue to next task
- ❌ "Issues: [description]" - Fix before proceeding
Checkpoints are configured during project initialization or can be added to existing projects:
# .context-forge/checkpoints.yaml
checkpoints:
- name: "Database Migration"
phase: "infrastructure"
requires_approval: true
validation_steps:
- "Run migration scripts"
- "Verify data integrity"
- "Check rollback procedures"npm install -g context-forge
- Node.js 18+ and npm 7+
- Git (for version control)
- A code editor (VS Code recommended)
# Initialize a new project
context-forge init
# Or use npx without installation
npx context-forge initNote: Context Forge is a CLI tool and should be installed globally. Do not install it as a project dependency with npm install context-forge as this will add unnecessary files to your project.
# Initialize in current directory
context-forge init
# Specify output directory
context-forge init --output ./my-project
# Use with existing PRD file
context-forge init --prd ./requirements.md
# Skip interactive prompts with config
context-forge init --config ./context-forge.json
# Run validation on existing project
context-forge validate
# Retrofit existing projects with AI-optimized documentation
context-forge analyze
# Execute PRPs with Claude Code for one-pass implementation
context-forge run-prp feature-name
# NEW: Plan technology migration
context-forge migrate --target "Next.js"
# NEW: Copy Claude Code hooks from another project
context-forge copy-hooks --source ../claude-hooks-repo/hooks$ context-forge init
? Project name: Analytics Dashboard
? Project type: fullstack
? Project description: Real-time analytics dashboard with data visualization
? How would you like to provide the PRD? Create new PRD
? Frontend framework: nextjs
? Backend framework: fastapi
? Database: postgresql
? Select features: authentication, dashboard, realtime-updates, data-export
? Project timeline: standard
? Team size: small
? Enable PRP generation? Yes
? Enable validation system? Yes
? Enable Human-in-the-Loop checkpoints? Yes
? Enable Claude Code hooks? Yes
✅ Project initialized successfully!
Generated files:
- CLAUDE.md (Next.js 15 specific configuration)
- Docs/Implementation.md (4 development stages)
- Docs/project_structure.md
- PRPs/base.md (Implementation prompt with validation gates)
- .claude/commands/ (20+ slash commands)
- .claude/hooks/ (4 Claude Code hooks)
- .context-forge/config.json
Next steps:
1. cd analytics-dashboard
2. Review CLAUDE.md for project rules
3. Use /prime-context to load project knowledge
4. Start with Stage 1 in Docs/Implementation.md$ context-forge init --output user-service
? Project name: User Service
? Project type: api
? Project description: User management microservice with JWT auth
? Frontend framework: none
? Backend framework: express
? Database: mongodb
? Authentication method: jwt
? Enable Docker support? Yes
? Enable GitHub Actions? Yes
Generated structure:
user-service/
├── CLAUDE.md # Express.js specific rules
├── Docs/
├── PRPs/
├── Dockerfile
├── docker-compose.yml
└── .github/workflows/# context-forge.json
{
"projectName": "E-Commerce Platform",
"projectType": "fullstack",
"description": "Modern e-commerce platform with AI recommendations",
"prd": {
"content": "# E-Commerce Platform\n\n## Overview\n...",
"features": [
{
"id": "auth",
"name": "User Authentication",
"priority": "must-have",
"complexity": "medium"
},
{
"id": "catalog",
"name": "Product Catalog",
"priority": "must-have",
"complexity": "complex"
},
{
"id": "cart",
"name": "Shopping Cart",
"priority": "must-have",
"complexity": "medium"
},
{
"id": "ai-recommendations",
"name": "AI Product Recommendations",
"priority": "should-have",
"complexity": "complex"
}
]
},
"techStack": {
"frontend": "react",
"backend": "django",
"database": "postgresql",
"cache": "redis",
"search": "elasticsearch"
},
"extras": {
"prp": true,
"validation": true,
"docker": true,
"cicd": true,
"testing": true
}
}
# Run with config
$ context-forge init --config context-forge.json --output ecommerce-platformYou're building an MVP for a startup. You need to move fast but maintain quality:
# 1. Initialize with MVP timeline
context-forge init --preset startup-mvp
# 2. Review generated Implementation.md
cat Docs/Implementation.md
# Shows 2-week sprint plan with daily tasks
# 3. Start development with Claude Code
# Open CLAUDE.md in Claude Code
# Follow Stage 1 tasks systematically
# 4. Validate progress daily
context-forge validate --levels syntax,testsMigrating a legacy system to modern stack:
# 1. Create detailed PRD first
context-forge init --prd legacy-migration-prd.md
# 2. Select enterprise options
# - Choose 'enterprise' timeline
# - Enable all validation options
# - Select comprehensive testing
# 3. Generated structure includes:
# - Migration strategy in Implementation.md
# - Rollback procedures
# - Comprehensive test suites
# - Security audit checklists24-hour hackathon, need to prototype fast:
# 1. Quick setup
npx context-forge init --preset hackathon
# 2. Skip optional features
# - Disable PRP (too detailed for hackathon)
# - Basic validation only
# - Focus on core features
# 3. Get building in < 5 minutes
# CLAUDE.md has simplified rules for rapid developmentNEW in v3.1.3+: The analyze command allows you to retrofit existing codebases with AI-optimized documentation. This is perfect for:
- Adding AI assistance to legacy projects
- Upgrading existing projects with modern context engineering
- Planning new features for established codebases
- Generating PRPs for upcoming development work
- Smart Analysis: Automatically detects your tech stack, project structure, and existing documentation
- Interactive Setup: Asks about your future development plans
- Non-Destructive: Never overwrites existing files (appends to CLAUDE.md with clear markers)
- Feature PRPs: Generates individual PRP files for each planned feature
- Comprehensive Summary: Creates a detailed retrofit summary with file tree visualization
# Run in your existing project directory
cd /path/to/your/project
context-forge analyze
# Specify output directory
context-forge analyze --output ./ai-docs
# Target specific IDEs
context-forge analyze --ide claude,cursor
# Skip AI analysis for faster setup
context-forge analyze --no-ai📁 Generated Files:
├── CLAUDE.md (UPDATED - appended retrofit section)
├── Docs/
│ ├── Implementation.md
│ ├── project_structure.md
│ ├── UI_UX_doc.md
│ └── Bug_tracking.md
└── PRPs/
├── user-authentication-prp.md
├── payment-integration-prp.md
└── api-v2-prp.md
The analyze command is intelligent enough to:
- Detect if you're using TypeScript, Python, or other languages
- Identify frameworks like React, Next.js, Express, FastAPI
- Find existing documentation to use as context
- Ask about your future plans to generate relevant PRPs
NEW in v3.1.4: The migrate command helps you safely transition between technology stacks with comprehensive planning, risk analysis, and rollback strategies.
Perfect for:
- Modernizing legacy applications (e.g., jQuery → React, Flask → FastAPI)
- Switching frameworks (e.g., Express → Next.js, Django → FastAPI)
- Adopting new technologies while maintaining production stability
- Planning complex migrations with shared resources (databases, auth systems)
- Analyzes Current Stack: Detects your existing technology and architecture
- Assesses Complexity: Calculates migration risks and shared resource dependencies
- Creates Phased Plan: Generates step-by-step migration with checkpoints
- Provides Safety Net: Includes comprehensive rollback procedures
- Monitors Progress: Tracks migration status with validation gates
# Interactive migration planning
context-forge migrate
# Specify target technology
context-forge migrate --target "Next.js"
# Quick mode (skip detailed analysis)
context-forge migrate --quick --target "FastAPI"
# Analyze only (no file generation)
context-forge migrate --analyze-only🔄 Migration Analysis Complete!
Source: Flask + Jinja2 + SQLAlchemy
Target: Next.js + FastAPI + Prisma
Complexity: HIGH (Score: 78/100)
Recommended Strategy: parallel-run
📁 Generated Migration Files:
├── CLAUDE.md (Migration-aware configuration)
├── PRPs/
│ ├── migration-overview.md
│ ├── phase-1-infrastructure.md
│ ├── phase-2-api-migration.md
│ ├── phase-3-frontend-migration.md
│ └── rollback-procedures.md
└── .claude/
├── commands/migration/
│ ├── migration-status.md
│ ├── migration-checkpoint.md
│ └── migration-rollback.md
└── hooks/
├── MigrationCheckpoint.py
└── DataIntegrityCheck.py
- Shared Resource Detection: Identifies databases, auth systems, and APIs used by both systems
- Risk Assessment: Analyzes potential breaking changes and data integrity risks
- Parallel-Run Support: Enables running old and new systems simultaneously
- Checkpoint System: Human verification at critical migration milestones
- Rollback Planning: One-command rollback to any checkpoint
- Progress Monitoring: Real-time migration status and health checks
- Big-Bang: Complete cutover (low complexity projects)
- Incremental: Feature-by-feature migration (medium complexity)
- Parallel-Run: Both systems active during transition (high complexity)
Context Forge creates IDE-specific documentation structures:
project-folder/
├── CLAUDE.md # Main context file with tech-stack specific rules
├── Docs/
│ ├── Implementation.md # Staged development plan
│ ├── project_structure.md # Folder organization
│ ├── UI_UX_doc.md # Design specifications
│ └── Bug_tracking.md # Bug tracking template
├── PRPs/ # Product Requirement Prompts (if enabled)
│ ├── {project}-prp.md # Base implementation PRP
│ ├── {project}-planning.md # Architecture planning (if enterprise/team)
│ └── {feature}-prp.md # Feature-specific PRPs (if retrofit)
├── .claude/ # Claude Code specific configuration
│ ├── commands/ # Slash commands (20+ commands)
│ │ ├── PRPs/ # PRP management commands
│ │ ├── development/ # Development workflow commands
│ │ ├── checkpoints/ # Human-in-the-loop commands
│ │ └── migration/ # Migration commands (if applicable)
│ └── hooks/ # Claude Code hooks (if enabled)
│ ├── PreCompact.py # Context preservation hook
│ ├── ContextRotation.py # Smart file switching
│ ├── PreSubmit.py # Quality gates
│ └── PRPTracking.py # Progress monitoring
└── ai_docs/ # AI documentation curation (if enabled)
└── README.md # Documentation guide
project-folder/
├── .cursorrules # Main Cursor rules file
└── .cursor/
└── rules/
├── global.md # Global development rules
├── project.md # Project-specific rules
├── prp-overview.mdc # PRP implementation overview
├── prp-stage-1.mdc # Foundation setup tasks
├── prp-stage-2.mdc # Core feature implementation
├── prp-stage-3.mdc # Advanced features & polish
└── prp-validation.mdc # Validation gates & checks
project-folder/
└── .clinerules/ # Configuration directory
├── README.md # Main configuration
├── context.md # Project context
├── rules.md # Development rules
├── patterns.md # Code patterns
├── prp-overview.md # PRP implementation overview
├── prp-stage-1.md # Foundation setup tasks
├── prp-stage-2.md # Core feature implementation
├── prp-stage-3.md # Advanced features & polish
└── prp-validation.md # Validation gates & checks
project-folder/
├── GEMINI.md # Main Gemini configuration
└── .gemini/
├── context/
│ ├── project.md # Project context
│ ├── architecture.md # Architecture docs
│ └── guidelines.md # Development guidelines
├── prp/ # PRP files (if features defined)
│ ├── overview.md # PRP implementation overview
│ ├── stage-1-foundation.md
│ ├── stage-2-core.md
│ ├── stage-3-advanced.md
│ └── validation.md
└── config.yaml # Gemini config with PRP settings
The main context file that Claude Code reads first. It contains:
- Project overview and tech stack
- Development philosophy (KISS, YAGNI)
- Code structure rules and limits
- Tech-stack specific guidelines
- Testing requirements
- Pre-commit checklist
Your roadmap with staged development:
- Stage 1: Foundation (1-2 weeks) - Setup, configuration, base structure
- Stage 2: Core Features (2-3 weeks) - Must-have functionality
- Stage 3: Advanced Features (2-3 weeks) - Should-have features
- Stage 4: Polish & Optimization (1-2 weeks) - Testing, performance
Each stage contains:
- Dependencies and prerequisites
- Detailed task checklist
- Validation requirements
- Expected deliverables
Advanced prompts for complex implementations:
- base.md - Implementation blueprint with pseudocode
- planning.md - Architecture diagrams and decisions
- spec.md - Technical specifications
- validation-gate.md - Quality checkpoints
When you run context-forge init, you'll be guided through:
- Project Information - Name, type, and description
- PRD Input - Provide or create product requirements
- Tech Stack Selection - Choose frontend, backend, and database
- Feature Selection - Pick core features for your MVP
- Configuration - Timeline, team size, and deployment
- Advanced Options - PRP, validation, AI docs
- Next.js 15 - App Router, Server Components, React 19
- React - SPA with TypeScript and modern patterns
- Vue.js 3 - Composition API and TypeScript
- Angular - Standalone components, RxJS
- Vanilla JavaScript - No framework approach
- FastAPI (Python) - Async, Pydantic v2, type hints
- Express.js (Node.js) - TypeScript, middleware patterns
- Django (Python) - MVT, ORM, admin interface
- Spring Boot (Java) - REST APIs, dependency injection
- Ruby on Rails - Convention over configuration
- PostgreSQL, MySQL, MongoDB, SQLite, Redis
Context Forge includes a powerful validation system that ensures code quality:
# Run all critical validations
context-forge validate
# Run specific validation levels
context-forge validate --levels syntax,tests
# Run all validations including optional ones
context-forge validate --all
# Generate detailed report
context-forge validate --report
# Validate in specific directory
context-forge validate --path ./my-project| Level | Description | Critical | Commands |
|---|---|---|---|
| syntax | Type checking and linting | ✅ Yes | tsc, eslint, mypy, etc. |
| tests | Unit and integration tests | ✅ Yes | jest, pytest, rspec, etc. |
| coverage | Code coverage analysis | ❌ No | With coverage reporters |
| build | Production build | ✅ Yes | Framework-specific build |
| security | Vulnerability scanning | ❌ No | npm audit, safety, etc. |
📊 Validation Report - Analytics Dashboard
==================================================
✅ Status: PASSED
Total: 5 | Passed: 5 | Failed: 0
✅ syntax:tsc --noEmit (342ms)
✅ syntax:eslint src --ext .ts,.tsx (567ms)
✅ tests:jest --coverage (4521ms)
✅ build:next build (8234ms)
✅ security:npm audit (1023ms)
Full report saved to: .validation-reports/latest-report.md
Skip interactive prompts with a configuration file:
{
"projectName": "My App",
"projectType": "fullstack",
"description": "A collaborative platform",
"techStack": {
"frontend": "nextjs",
"backend": "fastapi",
"database": "postgresql",
"auth": "jwt"
},
"features": [
{
"id": "auth",
"name": "Authentication",
"priority": "must-have"
}
],
"extras": {
"prp": true,
"validation": true,
"docker": true
}
}Use with: context-forge init --config context-forge.json
# Run the init command
context-forge init
# Answer the interactive prompts
# Context Forge will analyze your requirements and generate appropriate documentation# 1. Start with CLAUDE.md
cat CLAUDE.md
# This is your project's "constitution" - rules Claude Code will follow
# 2. Check your implementation plan
cat Docs/Implementation.md
# This breaks down development into manageable stages
# 3. Review project structure
cat Docs/project_structure.md
# This defines how your code should be organized- Open your project in Claude Code
- Add the entire project folder to Claude's context
- Start with Stage 1 tasks from Implementation.md
- Claude will follow the rules in CLAUDE.md automatically
# After completing each stage
context-forge validate
# Before committing code
context-forge validate --levels syntax,tests
# For comprehensive check
context-forge validate --all --report- Update Bug_tracking.md when you encounter issues
- Claude Code will learn from documented bugs
- Run validation frequently to maintain quality
Create your own templates in ~/.context-forge/templates/:
# Custom tech stack template
~/.context-forge/templates/claude/my-stack.md
# Custom validation commands
~/.context-forge/templates/validation/my-validation.jsonAdd pre/post hooks in .context-forge/hooks/:
# pre-init.sh - Run before initialization
#!/bin/bash
echo "Setting up environment..."
# post-init.sh - Run after initialization
#!/bin/bash
echo "Installing dependencies..."
npm install# .github/workflows/validate.yml
name: Context Forge Validation
on: [push, pull_request]
jobs:
validate:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- uses: actions/setup-node@v3
- run: npm install -g context-forge
- run: context-forge validate --all# Clone the repository
git clone https://github.com/webdevtodayjason/context-forge.git
cd context-forge
# Install dependencies
npm install
# Build the project
npm run build
# Run in development mode
npm run dev
# Run tests
npm test
# Run linting
npm run lintcontext-forge/
├── src/
│ ├── cli/ # CLI entry point and commands
│ ├── commands/ # Command implementations
│ ├── generators/ # Document generators
│ ├── templates/ # Handlebars templates
│ ├── data/ # Tech stack configurations
│ └── types/ # TypeScript definitions
├── templates/ # Document templates
└── tests/ # Test files
This project was inspired by and built upon the work of amazing developers:
- Rasmus Widing (Wirasm) - For the incredible PRPs-agentic-eng project that provided the foundation for our PRP (Product Requirement Prompt) system. The PRP methodology and validation loops are directly inspired by Rasmus's groundbreaking work.
- AILABS (@AILABS-393) - For the excellent educational content and YouTube tutorials on AI-assisted development, prompt engineering, and Claude Code workflows
- AI Labs Discord Community - For feedback, ideas, and support
- Dynamous.ai Community - For pioneering work in AI-assisted development and collaborative innovation
- Andre Karpathy - Context engineering principles
- Claude Code by Anthropic - The AI assistant this tool is designed for
- Commander.js - CLI framework
- Inquirer.js - Interactive prompts
- Handlebars - Template engine
Contributions are welcome! Please read our Contributing Guide for details on our code of conduct and the process for submitting pull requests.
- 🐛 Report bugs and issues
- 💡 Suggest new features
- 📝 Improve documentation
- 🔧 Add new tech stack templates
- 🌐 Translate documentation
- ⭐ Star the project!
This project is licensed under the MIT License - see the LICENSE file for details.
- Repository: github.com/webdevtodayjason/context-forge
- npm Package: npmjs.com/package/context-forge
- Issues: GitHub Issues
- Discussions: GitHub Discussions
Made with ❤️ by the Context Forge community
Empowering developers to build smarter, not harder
