Claude Code Configs

My personal Claude Code configuration, forked from affaan-m/everything-claude-code.

What's Different in This Fork

• Language-agnostic structure - Universal configs at user-level, language-specific templates for projects
• Auto-detection - SessionStart hook automatically detects project type and injects relevant rules
• Multi-language support - TypeScript and Python templates included
• Universal hooks - Single hooks file handles all languages with smart file extension matching

---

Structure

claude-code-configs/
│
├── user-level/                    # Universal configs → symlink to ~/.claude/
│   ├── agents/                    # Language-agnostic agents
│   ├── rules/                     # Universal principles (no code examples)
│   ├── commands/                  # Slash commands
│   ├── hooks/                     # Universal + all language hooks
│   │   ├── hooks.json
│   │   ├── auto-detect/           # Project language detection
│   │   ├── memory-persistence/
│   │   └── strategic-compact/
│   ├── skills/
│   └── contexts/
│
├── project-templates/             # Copy to project/.claude/ as needed
│   ├── typescript/                # TypeScript/JavaScript projects
│   │   ├── rules/                 # Zod, React patterns, TS examples
│   │   ├── agents/                # Jest/Vitest, tsc-specific
│   │   ├── hooks/                 # (Optional - already in universal)
│   │   ├── skills/
│   │   └── CLAUDE.md
│   │
│   └── python/                    # Python projects
│       ├── rules/                 # Pydantic, FastAPI, type hints
│       ├── agents/                # pytest, mypy-specific
│       ├── hooks/                 # (Optional - already in universal)
│       ├── skills/
│       └── CLAUDE.md
│
├── agents/                        # Original agents (from upstream)
├── rules/                         # Original rules (from upstream)
├── commands/                      # Original commands (from upstream)
├── skills/                        # Original skills (from upstream)
├── hooks/                         # Original hooks (from upstream)
├── mcp-configs/                   # MCP server configurations
└── examples/                      # Example configurations

---

Quick Start

1. Symlink user-level configs

cd /path/to/claude-code-configs

ln -sf "$(pwd)/user-level/agents" ~/.claude/agents
ln -sf "$(pwd)/user-level/rules" ~/.claude/rules
ln -sf "$(pwd)/user-level/commands" ~/.claude/commands
ln -sf "$(pwd)/user-level/skills" ~/.claude/skills
ln -sf "$(pwd)/user-level/contexts" ~/.claude/contexts
ln -sf "$(pwd)/user-level/hooks" ~/.claude/hooks

2. Start coding

The auto-detection hook will:

• Detect project type on session start (via package.json, pyproject.toml, etc.)
• Inject language-specific rules into context
• Apply appropriate hooks (Prettier for TS, ruff for Python, etc.)

3. For new/uninitialized projects

If no project files exist yet:

# Option A: Use the init command
/init typescript
# or
/init python

# Option B: Create a quick override file
echo "typescript" > .claude-lang

---

How Auto-Detection Works

SessionStart Hook

On every session, detect-language.sh runs and:

1. Checks for monorepo structure first
2. Falls back to single-project detection
3. Checks for .claude-lang override file
4. Scans for project markers:
   • package.json / tsconfig.json → TypeScript
   • pyproject.toml / requirements.txt → Python
   • go.mod → Go
   • Cargo.toml → Rust
5. Outputs language-specific rules as context

Monorepo Support

Automatically detects common monorepo structures:

myproject/
├── backend/           # Python (FastAPI)
│   └── pyproject.toml
├── frontend/          # TypeScript (Next.js)
│   └── package.json
└── packages/
    ├── ui/            # TypeScript
    └── shared/        # TypeScript

Detected patterns:

• backend/, server/, api/, services/*
• frontend/, client/, web/
• packages/* (pnpm/yarn workspaces)
• apps/* (Turborepo)
• services/* (microservices)

What you'll see on SessionStart:

# ═══════════════════════════════════════════════════════════
# MONOREPO DETECTED
# ═══════════════════════════════════════════════════════════

## Project Structure

| Path | Language | Type |
|------|----------|------|
| `backend/` | python | backend |
| `frontend/` | typescript | frontend |

## Working With This Monorepo

- Rules are loaded based on file extensions (works across all subdirs)
- Hooks apply automatically: `.ts`→Prettier/tsc, `.py`→ruff/mypy
- For subdirectory-specific overrides, create `<subdir>/.claude-lang`

Per-subdirectory overrides:

# Override detection for a specific subdirectory
echo "python" > backend/.claude-lang
echo "typescript" > frontend/.claude-lang

Universal Hooks

The hooks file includes all languages with smart matchers:

Hook	Files	Action
Prettier	*.ts, *.tsx, *.js, *.jsx	Auto-format
tsc	*.ts, *.tsx	Type check
console.log warning	*.ts, *.tsx, *.js, *.jsx	Warn
ruff	*.py	Format + lint
mypy	*.py	Type check
print() warning	*.py	Warn

---

Project Templates

For project-specific overrides, copy the appropriate template:

# TypeScript project
cp -r project-templates/typescript/* your-project/.claude/

# Python project
cp -r project-templates/python/* your-project/.claude/

This is optional - the auto-detection and universal hooks handle most cases.

---

MCP Setup (Unity/3D Projects)

The Unity template includes MCP servers for 3D asset generation. Here's how to set them up:

Meshy AI MCP

Generates 3D models from text or images using Meshy AI.

1. Get an API key from meshy.ai/settings/api

2. Set the environment variable:

   # Add to ~/.zshrc or ~/.bashrc
   export MESHY_API_KEY="your_api_key_here"

3. The MCP config (already in Unity template):

   {
     "meshy-ai": {
       "command": "npx",
       "args": ["-y", "meshy-ai-mcp-server"],
       "env": {
         "MESHY_API_KEY": "${MESHY_API_KEY}"
       }
     }
   }

4. Restart Claude Code to load the new MCP

Source: pasie15/meshy-ai-mcp-server

Blender MCP

Enables Claude to control Blender for 3D modeling.

Prerequisites:

• Blender installed
• uv package manager (brew install uv on macOS)

Setup:

1. Download the addon from blender-mcp releases

   • Get addon.py from the latest release

2. Install in Blender:

   • Open Blender → Edit → Preferences → Add-ons
   • Click "Install..." → Select the downloaded addon.py
   • Enable the checkbox next to "Blender MCP"

3. Start the server:

   • In Blender's sidebar (press N), find the "BlenderMCP" tab
   • Click "Start MCP Server"

4. The MCP config (already in Unity template):

   {
     "blender": {
       "command": "uvx",
       "args": ["blender-mcp"]
     }
   }

5. Restart Claude Code with Blender's MCP server running

Source: ahujasid/blender-mcp

---

Credits

Based on Everything Claude Code by @affaanmustafa.

Read the original guides:

• The Shorthand Guide to Everything Claude Code
• The Longform Guide to Everything Claude Code

---

License

MIT