Claude Code Integration

Native MCP Integration

12 dedicated tools for Claude - no HTTP calls needed, just natural conversation

🔗

codeeasy_get_context

Full project context in one call - frameworks, patterns, structure, recent activity. Optional focus filtering for auth, api, database, frontend, or testing.

📋

codeeasy_store_requirement

Persist requirements across sessions. Technical, architectural, design, enterprise, or functional - all types supported with priority levels.

💡

codeeasy_store_decision

Document architectural decisions with full context, rationale, alternatives considered, and consequences. Future sessions understand past choices.

⚠

codeeasy_preflight_check

Check for conflicts before making changes. Returns active requirements, relevant decisions, pending tasks, and potential issues for the target area.

🧠

codeeasy_get_session_history

Access previous session summaries - what was done, decisions made, files changed, and recommended next steps. True persistent memory.

💾

codeeasy_store_session_summary

Save session summaries at the end of work. Next session picks up exactly where you left off with full context preserved.

          
          
          
          ~/.claude/claude_desktop_config.json
        

// Add Code Easy as an MCP server
{
  "mcpServers": {
    "codeeasy": {
      "command": "node",
      "args": ["/path/to/easycodeview/mcp-server/index.js"],
      "env": {
        "CODE_EASY_URL": "http://localhost:3001"
      }
    }
  }
}
        

Session Memory That Persists

The #1 limitation of AI assistants is forgetting everything between sessions. Code Easy solves this completely.

Session summaries - What was accomplished, decisions made
Next steps - Recommended actions for the next session
Files changed - Track what was modified
Decision history - Full rationale preserved forever

            
            
            
            Session Memory API
          

// At session start, fetch previous context
GET /api/claude/sessions/:repo/latest

{
  "summary": "Implemented JWT auth flow",
  "next_steps": "Add refresh token handling",
  "decisions_made": ["Use HS256 for tokens"],
  "files_changed": ["auth.js", "middleware.js"]
}

// At session end, save for next time
POST /api/claude/sessions/:repo
{
  "summary": "Added refresh tokens",
  "next_steps": "Add token rotation"
}
          

Pre-flight Conflict Detection

Before making changes to any area, Claude can check for potential conflicts and get relevant context.

Active requirements for the target area
Relevant decisions that may affect changes
Pending tasks that may overlap
Conflict warnings for protected areas

            
            
            
            Pre-flight Check
          

// Before modifying authentication
GET /api/claude/preflight/:repo?area=auth&action=modify

{
  "conflicts": [],
  "relevant_decisions": [{
    "title": "Use JWT tokens",
    "rationale": "Stateless auth required"
  }],
  "relevant_requirements": [{
    "title": "OAuth2 support",
    "priority": "high"
  }],
  "pending_tasks": [
    "Add refresh token rotation"
  ]
}
          

Why Claude Code + Code Easy?

Fill the gaps in Claude's native capabilities with persistent project intelligence

🧠

Persistent Memory

Requirements, plans, and decisions survive across sessions. Claude remembers what was decided and why - no more re-explaining context.

👁

Real-Time Awareness

Watch Claude work in real-time. Every file read, edit, and command is tracked and visualized. See your codebase evolve as Claude builds.

🎯

Instant Context

One API call gives Claude full project understanding - frameworks, patterns, dependencies, conventions. No manual exploration needed.

📊

Quality Intelligence

Complexity analysis, dead code detection, security scans, and test coverage. Claude can assess code health before making changes.

📝

Decision Records

Architectural Decision Records (ADRs) capture the "why" behind choices. Future sessions understand past rationale instantly.

🚀

Fast-Track Templates

Pre-built requirement templates for web apps, APIs, mobile, and data pipelines. Start new projects with requirements pre-populated.

Claude Code API

REST endpoints designed specifically for AI assistant integration

Project Context in One Call

Claude gets complete project understanding instantly - no need to grep through files or explore manually.

File counts, lines of code, language breakdown
Auto-detected frameworks (React, Vue, Express, Next.js, etc.)
Architectural patterns (MVC, service layers, hooks)
Code conventions and naming patterns
Recent activity and most-changed files

            
            
            
            GET /api/claude/context/:repo
          

// Response
{
  "overview": {
    "total_files": 247,
    "total_lines": 18420,
    "languages": ["JavaScript", "TypeScript"]
  },
  "frameworks": ["React", "Express", "Prisma"],
  "patterns": ["component-based", "hooks"],
  "conventions": {
    "naming": "camelCase",
    "components": "PascalCase"
  },
  "issues": {
    "todos": 12,
    "complexity_warnings": 3
  }
}
          

Requirements That Persist

Store technical, architectural, and functional requirements that survive across Claude sessions.

5 requirement types: Technical, Architectural, Design, Enterprise, Functional
Status tracking: Proposed → Approved → Implemented
Priority levels: Critical, High, Medium, Low
CSV import/export for bulk operations

            
            
            
            POST /api/claude/requirements/:repo
          

// Create a requirement
{
  "type": "architectural",
  "title": "Use PostgreSQL for persistence",
  "description": "ACID compliance required",
  "status": "approved",
  "priority": "critical"
}

// Claude can query existing requirements
GET /api/claude/requirements/myproject
GET /api/claude/requirements/myproject?type=technical
          

Implementation Plans with Tasks

Break complex features into ordered, trackable tasks with dependencies.

Hierarchical task structures with ordering
Task dependencies (depends_on field)
Status: Pending → In Progress → Completed → Blocked
Progress tracking across sessions

            
            
            
            Plans & Tasks API
          

// Create a plan
POST /api/claude/plans/myproject
{
  "title": "Implement Authentication",
  "status": "active"
}

// Add tasks to the plan
POST /api/claude/plans/myproject/1/tasks
{
  "title": "Create User model",
  "order_index": 1,
  "status": "completed"
}

// Mark task complete as you work
PUT /api/claude/plans/myproject/tasks/2
{ "status": "completed" }
          

Architectural Decision Records

Document the "why" behind technical choices. Future Claude sessions understand past decisions instantly.

Context: What problem prompted this decision?
Decision: What was chosen?
Rationale: Why this option over others?
Alternatives: What was considered and rejected?
Consequences: Tradeoffs and implications

            
            
            
            POST /api/claude/decisions/:repo
          

{
  "title": "Use JWT for authentication",
  "context": "Need stateless auth for API",
  "decision": "JWT with refresh tokens",
  "rationale": "Scales horizontally, no session store needed",
  "alternatives": [
    "Session cookies",
    "OAuth only"
  ],
  "consequences": "Must handle token refresh, slightly larger requests",
  "status": "accepted"
}
          

Quick Setup

Connect Claude Code to Code Easy in under 2 minutes

Integration Steps

Start Code Easy

Run npm start in the Code Easy directory

Add Repository

Configure your project in config.json

Configure Hooks

Add hooks to ~/.claude/settings.json

Start Coding

Claude now has full project awareness

          
          
          
          ~/.claude/settings.json
        

{
  "hooks": {
    "PostToolUse": [{
      "matcher": "Edit|Write|Read|Bash|Glob|Grep",
      "hooks": [{
        "type": "http",
        "url": "http://localhost:3001/api/hooks/tool-use",
        "timeout": 5
      }]
    }],
    "SessionStart": [{
      "hooks": [{
        "type": "http",
        "url": "http://localhost:3001/api/hooks/session?event=start"
      }]
    }],
    "SessionEnd": [{
      "hooks": [{
        "type": "http",
        "url": "http://localhost:3001/api/hooks/session?event=end"
      }]
    }]
  }
}
        

Full API Reference

All endpoints available for Claude Code integration

Endpoint	Method	Description
/api/claude/context/:repo	GET	Full project context with optional ?focus= filtering (auth, api, database, frontend, testing)
/api/claude/preflight/:repo	GET	Pre-flight conflict check with ?area= and ?action= params
/api/claude/sessions/:repo	GET/POST	Session summaries - persistent memory across sessions
/api/claude/sessions/:repo/latest	GET	Get most recent session summary for quick context
/api/claude/analysis/:repo	GET	Focused analysis (security, performance, testing, docs)
/api/claude/scan/:repo	POST	Trigger fresh data scan
/api/claude/status/:repo	GET	Check data freshness and counts
/api/claude/requirements/:repo	GET/POST/PUT/DELETE	Requirements CRUD with type filtering
/api/claude/plans/:repo	GET/POST/PUT/DELETE	Implementation plans CRUD
/api/claude/plans/:repo/:id/tasks	GET/POST/PUT/DELETE	Plan tasks CRUD with dependencies
/api/claude/decisions/:repo	GET/POST/PUT/DELETE	Architectural Decision Records (ADRs)
/api/hooks/tool-use	POST	Log Claude tool usage with real-time tracking
/api/hooks/session	POST	Session events with contextual nudges returned

View Complete API Documentation

Why This Is a 10/10 for Claude

Every major limitation addressed, every workflow optimized

Before Code Easy

❌ Every session starts from scratch
❌ Manual file exploration to understand context
❌ No memory of past decisions
❌ Re-explain requirements every time
❌ No visibility into what changed
❌ Risk of conflicting changes

With Code Easy

Sessions resume with full context
Instant project understanding via MCP
ADRs preserve decision rationale
Requirements persist forever
Real-time change visualization
Pre-flight checks prevent conflicts

The Complete Claude Code Enhancement Stack

12 MCP tools + REST API + Real-time hooks + Session memory + Pre-flight checks + 7 visualizations

MCP Tools

API Endpoints

Visualizations

∞

Session Memory

The Ultimate Claude Code Command Center