Claude Code Organizer

English | 简体中文 | 繁體中文 | 廣東話 | 日本語 | 한국어 | Español | Bahasa Indonesia | Italiano | Português | Türkçe | Tiếng Việt | ไทย

A visual config manager for Claude Code. See everything Claude has stored — memories, skills, MCP servers, rules, commands, agents — organized by scope. Drag items between scopes, find duplicates, clean up the mess.

First open source project — built solo with Claude Code. If it helped you, a star would make my week.

_{Demo video recorded by AI automatically using Pagecast}

The Problem

Two things happen silently every time you use Claude Code — and neither one is visible to you.

Problem 1: Where you put things matters — and Claude puts them in the wrong place

Claude Code has a scope hierarchy: Global → Workspace → Project. Anything in Global loads into every session on your machine. Anything in a Project scope only loads when you're in that directory. Where a memory, skill, or MCP server sits determines which sessions it affects.

The problem: Claude doesn't care about scope when it creates things. It dumps everything into whatever scope matches your current directory. Over time, this turns into a mess:

Skills in the wrong scope affect the wrong projects:

• You build a deploy skill while working in your backend repo. It lands in that project's scope. But you want it everywhere — it should be in Global. Without moving it, your other projects can't see it. You end up creating another one in other projects.
• A Python-specific testing skill sitting in Global gets loaded into every React frontend session. It wastes tokens and confuses Claude with irrelevant instructions.

Memories pile up and duplicate:

• You tell Claude "always use ESM imports" while inside a project. That memory is trapped in that project scope — your other projects don't get it.
• My experience: Claude created 3 separate memories about Slack updates, all saying the same thing. Each one loads every session.

MCP servers silently reinstall across scopes:

Teams installed twice, Gmail three times, Playwright three times. You configured them in one scope, Claude reinstalled them in another. Each duplicate loads independently.

You can manage this with CLI commands or by asking Claude — ls one directory, cat each file, ask Claude to move this here, delete that, show me what's in this scope. But you're spending turns and tokens just to understand the layout, one item at a time, before you can even decide what to do with it. There's no single view that shows you the full picture: all items, all scopes, all inheritance, at once.

Problem 2: You have no idea how much context is already used

All of this wrong-scope and duplicate config has a cost. This is a real project directory after two weeks of use:

21.9K tokens immediately loaded into context, with another 115.4K deferred for MCP tools. On a 200K window, that's 11% gone before you type — and grows as Claude invokes tools during the session. The fuller the context, the less accurate Claude becomes (context rot).

And these numbers only cover what we can measure offline. During a session, Claude silently adds more: rule files re-injected after every tool call, file change diffs, and your full conversation history resent on every API call.

The fix: a visual config manager

npx @mcpware/claude-code-organizer

Think of it like a file manager for ~/.claude/. You can do everything in terminal too — but sometimes you need to see the whole tree to understand what's going on.

The workflow: see what's loaded and where it comes from → spot duplicates and wrong-scope items → drag-and-drop to the right scope or delete → check Context Budget → refresh → repeat until your initial load is lean.

First run auto-installs a /cco skill — after that, just type /cco in any Claude Code session to open the dashboard.

Example: Move a skill to the right scope

You built a deploy skill while working in ~/myapp. It ended up in that project's scope — only visible when you're in ~/myapp. But it should be Global so all your projects can use it. Open the dashboard, find the skill, drag it from Project to Global. Done. One drag. Now every project on your machine can use it.

Example: See what a project actually inherits

You open a deeply nested project and Claude is behaving weirdly — following instructions you don't remember setting. Click the project in the dashboard. You see its own items, plus everything inherited from parent scopes: workspace-level memories, global skills, MCP servers from two levels up. Now you know exactly what's influencing Claude in this directory.

Example: Find and clean up duplicates

Claude created the same memory in 3 scopes. An MCP server got installed in both Global and your project. Switch to By Category view — all items of the same type across all scopes grouped together. Duplicates jump out immediately. Preview each one, decide which to keep, delete the rest.

Comparison

How does this compare to other Claude Code tools?

Features

• Scope-aware hierarchy — See all items organized as Global > Workspace > Project, with inheritance indicators
• Drag-and-drop — Move memories, skills, commands, agents, rules, MCP servers, and plans between scopes
• Undo everything — Every move and delete has an undo button — restore instantly, including MCP JSON entries
• Bulk operations — Select mode: tick multiple items, move or delete all at once
• Same-type safety — Each category moves to its own directory — memories to memory/, skills to skills/, commands to commands/, etc.
• Search & filter — Real-time search across all items, filter by category with smart pill hiding (zero-count pills collapse into "+N more")
• Context Budget — See what's always loaded vs deferred, per-item token counts, inherited scope breakdown, and 200K/1M context window toggle
• Detail panel — Click any item to see full metadata, content preview, file path, and open in VS Code
• Session inspector — Parsed conversation previews with speaker labels, session titles, and metadata
• 11 categories — Memories, skills, MCP servers, commands, agents, rules, configs, hooks, plugins, plans, and sessions
• Bundled skill detection — Groups skills by source bundle via skills-lock.json
• Contextual Claude Code prompts — "Explain This", "Edit Content", "Edit Command", "Edit Agent", "Resume Session" buttons that copy to clipboard
• Auto-hide detail panel — Panel stays hidden until you click an item, maximizing content area
• Resizable panels — Drag dividers to resize sidebar, content area, and detail panel
• Real file moves — Actually moves files in ~/.claude/, not just a viewer
• Path traversal protection — All file endpoints validate paths are within HOME directory
• Cross-device support — Automatic copy+delete fallback when rename fails across filesystems (Docker/WSL)
• 124 E2E tests — Playwright test suite covering scanner accuracy, context budget calculations, filesystem verification, security, and all 11 categories

Quick Start

Option 1: npx (no install needed)

npx @mcpware/claude-code-organizer

Option 2: Global install

npm install -g @mcpware/claude-code-organizer
claude-code-organizer

Option 3: Ask Claude

Paste this into Claude Code:

Run npx @mcpware/claude-code-organizer — it's a dashboard for managing all Claude Code resources. Tell me the URL when it's ready.

Opens a dashboard at http://localhost:3847 that works directly with your real ~/.claude/ directory. Next time, just type /cco in Claude Code to reopen.

What It Manages

Scope Hierarchy

Global                       <- applies everywhere
  Company (workspace)        <- applies to all sub-projects
    CompanyRepo1             <- project-specific
    CompanyRepo2             <- project-specific
  SideProjects (project)     <- independent project
  Documents (project)        <- independent project

Child scopes inherit parent scope's memories, skills, MCP servers, commands, agents, and rules.

How It Works

1. Scans ~/.claude/ — discovers all projects, memories, skills, MCP servers, commands, agents, rules, hooks, plugins, plans, and sessions
2. Resolves scope hierarchy — determines parent-child relationships from filesystem paths
3. Renders dashboard — three-panel layout: sidebar scope tree, category-grouped items, detail panel with content preview
4. Handles moves — drag or click "Move to...", moves files on disk with safety checks, undo support
5. Handles deletes — delete with undo, bulk delete, session cleanup

Platform Support

Project Structure

src/
  scanner.mjs       # Scans ~/.claude/ — 11 categories, pure data, no side effects
  mover.mjs         # Moves/deletes files between scopes — safety checks + undo support
  server.mjs        # HTTP server — 8 REST endpoints
  mcp-server.mjs    # MCP server — 4 tools for AI clients (scan, move, delete, destinations)
  ui/
    index.html       # Three-panel layout with resizable dividers
    style.css        # All styling (edit freely, won't break logic)
    app.js           # Frontend: drag-drop, search, filters, bulk ops, undo, session preview
bin/
  cli.mjs            # Entry point (--mcp flag for MCP server mode)

Frontend and backend are fully separated. Edit src/ui/ files to change the look without touching any logic.

API

The dashboard is backed by a REST API:

Roadmap

Have a feature idea? Open an issue.

License

MIT

More from @mcpware

Author

ithiria894 — Building tools for the Claude Code ecosystem.