Claude Code AI工具包

MindForge - AI Toolkit for Claude Code

中文文档 | English

MindForge is a comprehensive toolkit for managing MCP (Model Context Protocol) services, AI Agents, and Skills, designed to supercharge your Claude Code development experience.

✨ Features

• Multi-language Support: Choose between English or Chinese versions of agents and skills
• Rich Agent Collection: Specialized agents for Java, Python, Go, Frontend, and System Architecture
• Reusable Skills: Domain-specific skills that can be composed and shared across agents
• MCP Services: Extensible collection of Model Context Protocol services
• Multi-harness Support: Claude Code, zcode, and Codex (OpenAI) install the same hooks, dictionary, and rules from one repository
• Prompt-only Writing Guidance: Concise Chinese expression rules or English ASD-STE100 guidance, without automatic lookup, reply interception or model review
• Three-tier Dictionary: Bundled → user-level (~/.claude/MindForge/) → project-level (mindforge.zh-dict.tsv in the repo, team-shared)
• MindForge CLI: One Go binary (installer / init dict / doctor) with the whole hook payload embedded
• Easy Setup: One-command installation script for Claude Code integration
• Flexible Tech Stack: Each component can use its own preferred technology stack

🚀 Quick Start with Claude Code

MindForge integrates seamlessly with Claude Code. Run the setup script to automatically configure all agents and skills:

# Use default language (English)
./setup-claude.sh

# Use Chinese
./setup-claude.sh --lang=zh-cn

# Use English (explicit)
./setup-claude.sh --lang=en

This creates symbolic links to your ~/.claude/ directory, allowing Claude Code to automatically load all agents and skills.

🎛️ User-Level Configuration

For personalized behavior across all your projects, you can configure user-level instructions:

# Copy user-level instructions to your Claude directory
cp user_claude_md/en/CLAUDE.md ~/.claude/CLAUDE.md    # English
cp user_claude_md/zh-cn/CLAUDE.md ~/.claude/CLAUDE.md  # Chinese

What user-level configuration provides:

• Global principles: Default behavior applied across all conversations
• Language preference: Set your preferred response language (English or Chinese)
• Search priority: Instructions for handling uncertain questions
• Safety rules: Confirmation requirements for destructive operations
• Built-in capability priority: Guidance on when to use agents/skills vs external tools

Note: User-level configuration is optional. If not configured, Claude Code will use its default behavior. Writing-style rules (controlled writing, ASD-STE100) are not in this file — the style-rules hook injects them, so keeping them out avoids sending the same rules twice. To use them without the hook, merge hooks/style-rules-en.md into the copied file.

🌍 Supported Languages

• en - English
• zh-cn - Simplified Chinese

🧩 Install as a Plugin (Claude Code, zcode & Codex)

Agents, skills, and the controlled-writing style rules hook are all distributed as plugins. Claude Code, zcode, and Codex read the same marketplace manifest (.claude-plugin/marketplace.json), so one repository serves all harnesses:

# Claude Code (inside a session)
/plugin marketplace add ProjAnvil/MindForge

# Agents + skills bundles (pick your language)
/plugin install mindforge-en@mindforge             # 9 agents + 19 skills (English)
/plugin install mindforge-zh-cn@mindforge          # 9 agents + 19 skills (Chinese)

# Controlled-writing style rules hook
/plugin install style-rules@mindforge              # English rules (default)
/plugin install style-rules-zh-cn@mindforge        # Concise Chinese writing guidance

# Codex (from your shell)
codex plugin marketplace add ProjAnvil/MindForge
codex plugin add mindforge-zh-cn@mindforge
codex plugin add style-rules-zh-cn@mindforge

zcode reads the same marketplace manifest: add https://github.com/ProjAnvil/MindForge.git as a plugin marketplace in your zcode client, then install mindforge-zh-cn@mindforge and style-rules-zh-cn@mindforge. The plugin ships a zcode-specific manifest (.zcode-plugin/plugin.json) so no unsupported hook registrations are ever loaded there.

Notes:

• Both style plugins use prompt-only guidance. They do not create dictionaries, register MCP servers or request model-based reply review.
• Plugin agents and skills are namespaced, e.g. /mindforge-en:git-guru and mindforge-en:code-reviewer, so they never conflict with personal or project ones.
• Plugin hooks use ${CLAUDE_PLUGIN_ROOT} (Claude Code) with a ${PLUGIN_ROOT} fallback, so no symlinks or settings.json merging are required.
• Restart the harness after installing.
• If you modify hooks/, agents/, or skills/, run make sync-plugins to refresh the plugin bundles (the style-rules-zh-cn plugin lives in hooks/ and needs no sync).

🧠 Scheme A: Guidance Before Generation

MindForge adds writing instructions to the existing model request, rather than creating a tool roundtrip or a second request to polish the response.

Claude Code also receives guidance at SubagentStart. No Stop, SubagentStop, PreToolUse check, prompt-based reviewer or terminology MCP server is registered. This does not guarantee that the model follows every writing rule, but MindForge does not add a review/rewriting model turn.

Existing dictionaries and optional source tools remain available for explicitly requested manual work; they are not read or enabled by the default reply path. mindforge init dict can still create a project reference file. See hooks/README.md for manual utilities and cost comparisons. When upgrading, reinstall and start a new session. Independently registered terminology MCP servers must be disabled separately if they are no longer wanted.

🔧 MindForge CLI (Go)

The mindforge binary is the installer, generator, and doctor. It installs only the shell injector, selected writing guide and language marker. Embedded dictionary references/templates support explicit CLI commands, not automatic reply checking. Install it straight from GitHub:

# Requires Go 1.24+
go install github.com/ProjAnvil/MindForge/cli/mindforge@latest

# Track the development branch instead:
# go install github.com/ProjAnvil/MindForge/cli/mindforge@main

# Fresh modules can lag in the public proxy/sum DB. If you hit a 404
# right after a release, install once via direct mode:
GOPROXY=direct GOSUMDB=off go install github.com/ProjAnvil/MindForge/cli/mindforge@latest

# Or grab a prebuilt binary from the GitHub releases page, or build from a checkout
git clone https://github.com/ProjAnvil/MindForge.git && cd MindForge && make cli

mindforge install                                        # interactive: pick harnesses + language
mindforge install --platform=claude,zcode,codex --lang=zh-cn --yes   # scripted
mindforge init dict                                      # generate mindforge.zh-dict.tsv here
mindforge doctor                                         # runtimes, registration, dictionary tiers

install registers prompt-only hooks into each harness's own config format (Claude Code settings.json, zcode config.json with hooks.enabled=true, Codex hooks.json), idempotently — foreign hook entries survive byte-for-byte. Kimi Code is detected but its installation adapter is not yet available. Platform details in cli/README.md.

🤖 Available Agents

• @code-reviewer - Expert code reviewer (software architecture, design patterns, code quality, SOLID principles)
• @frontend-engineer - Modern frontend expert (React, Vue, Svelte, TypeScript)
• @golang-backend-engineer - Go backend development expert (Fiber, Cobra, GORM, Clean Architecture)
• @ios-developer - Expert iOS Developer (Swift 6, SwiftUI, MVVM, TCA)
• @java-backend-engineer - Professional Java backend engineer (Spring Boot, MyBatis, Clean Architecture)
• @java-unit-test - Professional Java unit test generator (JUnit, Mockito, AssertJ)
• @product-manager - Product management expert (PRD, user stories, competitive analysis)
• @python-test-engineer - Professional Python testing engineer (pytest, unittest, pytest-asyncio)
• @system-architect - System architecture design expert (patterns, tech selection, ADR docs)

🎯 Available Skills

• api-design - API design (REST, GraphQL, gRPC)
• database-design - Database design and optimization
• enterprise-java - Enterprise Java development (Spring Boot, microservices)
• frontend-react - React ecosystem (Next.js, Server Components, Tailwind)
• frontend-svelte - Svelte ecosystem (SvelteKit, shadcn-svelte)
• frontend-vue - Vue ecosystem (Nuxt, Composition API, Pinia)
• git-guru - Advanced Git operations and version control mastery
• go-development - Go development (Fiber, Cobra, GORM)
• javascript-typescript - JavaScript/TypeScript development (Node.js, Express, React)
• product-management - Product management and strategy
• python-development - Python development (FastAPI, Django, Flask, asyncio)
• session-summary - Summarize current session context for seamless handover
• swift-development - Core Swift 6+ development (Concurrency, Macros, Testing)
• swiftui-development - Modern SwiftUI development (NavigationStack, Observation, SwiftData)
• system-architecture - System architecture design
• tech-documentation - Technical documentation writing
• testing - General testing skills (unit, integration, TDD/BDD)
• xcode-management - Xcode project management (automated file addition, project.pbxproj handling)

📁 Project Structure

mindforge/
├── agents/              # Claude Code format Agents (multi-language)
│   ├── en/             # English versions
│   │   ├── code-reviewer.md
│   │   ├── frontend-engineer.md
│   │   ├── golang-backend-engineer.md
│   │   ├── ios-developer.md
│   │   ├── java-backend-engineer.md
│   │   ├── java-unit-test.md
│   │   ├── product-manager.md
│   │   ├── python-test-engineer.md
│   │   └── system-architect.md
│   └── zh-cn/          # Chinese versions
│       ├── code-reviewer.md
│       ├── frontend-engineer.md
│       ├── golang-backend-engineer.md
│       ├── java-backend-engineer.md
│       ├── java-unit-test.md
│       ├── product-manager.md
│       ├── python-test-engineer.md
│       └── system-architect.md
├── skills/              # Claude Code format Skills (multi-language)
│   ├── en/             # English versions
│   │   ├── testing/SKILL.md
│   │   ├── enterprise-java/SKILL.md
│   │   ├── go-development/SKILL.md
│   │   ├── python-development/SKILL.md
│   │   ├── javascript-typescript/SKILL.md
│   │   ├── system-architecture/SKILL.md
│   │   ├── api-design/SKILL.md
│   │   ├── database-design/SKILL.md
│   │   ├── tech-documentation/SKILL.md
│   │   ├── frontend-development/SKILL.md
│   │   ├── git-guru/SKILL.md
│   │   └── xcode-management/SKILL.md
│   ├── zh-cn/          # Chinese versions
│   │   ├── testing/SKILL.md
│   │   ├── enterprise-java/SKILL.md
│   │   ├── go-development/SKILL.md
│   │   ├── python-development/SKILL.md
│   │   ├── javascript-typescript/SKILL.md
│   │   ├── system-architecture/SKILL.md
│   │   ├── api-design/SKILL.md
│   │   ├── database-design/SKILL.md
│   │   ├── tech-documentation/SKILL.md
│   │   ├── frontend-development/SKILL.md
│   │   ├── git-guru/SKILL.md
│   │   └── xcode-management/SKILL.md
│   └── scripts/        # Shared executable scripts for skills
│       └── xcode-management/
│           └── add_files_to_xcode.py  # Automated Xcode file addition
├── user_claude_md/      # User-level Claude instructions (multi-language)
│   ├── en/
│   │   └── CLAUDE.md   # English user-level instructions
│   └── zh-cn/
│       └── CLAUDE.md   # Chinese user-level instructions
├── hooks/               # prompt-only style plugin and optional research utilities
│   ├── hooks/           # hook registrations (shared / Claude-only variants)
│   ├── inject.py / inspect.py / inspect-file.py   # L1 / L2 / file-write guard
│   ├── term-dict-server.py    # prefixed MCP tools for lookup, annotations, workspace add/init
│   ├── zh_guard_common.py    # three-tier dictionary loading (shared library)
│   ├── terminology.tsv       # bundled dictionary (data flywheel)
│   └── .claude-plugin/ / .zcode-plugin/   # per-harness plugin manifests
├── cli/                 # mindforge CLI (Go): install / init dict / doctor
├── plugins/             # generated plugin bundles (mindforge-en/zh-cn, style-rules)
├── go.mod + assets.go   # Go module; embeds the hook payload into the CLI binary
├── templates/           # Templates for creating new resources
│   ├── agent-template-en.md      # English agent template
│   ├── agent-template-zhcn.md    # Chinese agent template
│   ├── skill-template-en.md      # English skill template
│   └── skill-template-zhcn.md    # Chinese skill template
├── mcp/                 # MCP services collection
│   ├── _template/
│   └── mcp-*/
├── evals/               # smelt evaluation suite (skills + agents, uv-managed)
│   ├── tests/           # lint, routing, behavior, evaluate (pytest)
│   ├── cases/           # doctor-ready module-level case files
│   └── reports/         # committed evaluate reports (md + json)
├── docs/                # Documentation
│   ├── README-zhcn.md   # Chinese README
│   └── agents-detail/   # Detailed agent documentation
│       ├── en/          # English detailed guides
│       │   ├── java-backend-engineer/README.md
│       │   ├── java-unit-test/README.md
│       │   ├── python-test-engineer/README.md
│       │   ├── system-architect/README.md
│       │   ├── golang-backend-engineer/README.md
│       │   └── frontend-engineer/README.md
│       └── zh-cn/       # Chinese detailed guides
│           ├── java-backend-engineer/README.md
│           ├── java-unit-test/README.md
│           ├── python-test-engineer/README.md
│           ├── system-architect/README.md
│           ├── golang-backend-engineer/README.md
│           └── frontend-engineer/README.md
├── Makefile             # Build and resource management
└── setup-claude.sh      # Claude Code setup script (supports --lang parameter)

🧪 Evaluation

The evals/ directory is a uv-managed Smelt harness covering both skills and the agent (subagent) definitions, in both languages:

• Static lint (deterministic, no API key): every SKILL.md and every agent file is linted against Claude Code's loading contract — for agents that includes frontmatter validity (name/description/tools/model), and whether each description actually routes (delegation triggers).
• Delegation routing (LLM): a simulated main agent sees each language's roster (names + descriptions) and must delegate specialty tasks to the right subagent, refuse to steal a sibling's specialty, and keep trivial tasks for itself.
• Behavior (LLM): each agent file runs as a real subagent — the markdown body is the system prompt and the tools: frontmatter allowlist is enforced — with the six core Claude Code tools (Read/Grep/Glob/Bash/Edit/ Write) backed by an isolated case workspace.
• Evaluate reports: full per-document evaluations (behavior + writing review + lint + suggestions + adversarial routing probes) saved to evals/reports/.

make eval        # deterministic evals: lint + plumbing (no API key, CI-safe)
make eval-llm    # full evals incl. behavior/routing/evaluate (needs SMELT_API_KEY)

Configuration lives in evals/.env (see evals/.env.template). Doctor-ready case files for on-demand mutation checks (run from evals/):

uv run smelt run cases/en_agent_routing_cases.py -v
uv run smelt doctor --agent ../agents/en/code-reviewer.md cases/en_agent_routing_cases.py

🛠️ Usage

Quick Start

# Show all available commands
make help

List Resources

# List all MCP services
make list-mcp

# List all Agents (shows both English and Chinese)
make list-agents

# List all Skills (shows both English and Chinese)
make list-skills

Create Resources from Templates

MindForge provides ready-to-use templates for creating new agents and skills. Templates are available in both English and Chinese.

Create a New Agent

# Create an English agent (default)
make init-agent AGENT=my-agent

# Create a Chinese agent
make init-agent AGENT=my-agent LANG=zh-cn

# Create an English agent (explicit)
make init-agent AGENT=my-agent LANG=en

What you get:

• A complete agent file with frontmatter (name, description, tools, model, skills)
• Structured sections for role definition, principles, and best practices
• Code templates and quality checklists
• Ready to customize for your specific use case

After creation:

1. Edit agents/{lang}/{agent-name}.md to customize the agent
2. Update the name, description, and system prompt
3. Specify which tools and skills the agent should use
4. Run ./setup-claude.sh --lang={lang} to activate

Create a New Skill

# Create an English skill (default, no scripts)
make init-skill SKILL=my-skill

# Create a skill with executable scripts
make init-skill SKILL=my-skill WITH_SCRIPTS=yes

# Create a Chinese skill
make init-skill SKILL=my-skill LANG=zh-cn

# Create a Chinese skill with scripts
make init-skill SKILL=my-skill LANG=zh-cn WITH_SCRIPTS=yes

What you get:

• A complete skill file with frontmatter (name, description, allowed-tools)
• Structured sections for expertise, principles, and best practices
• Code patterns, templates, and troubleshooting guides
• Quality checklists and decision frameworks
• (Optional) A shared skills/scripts/{skill-name}/ directory for executable scripts
• Ready to use across multiple agents

After creation:

1. Edit skills/{lang}/{skill-name}/SKILL.md to define capabilities
2. Add domain-specific knowledge and best practices
3. Include code templates and common patterns
4. (Optional) Add executable scripts to skills/scripts/{skill-name}/
5. Run ./setup-claude.sh --lang={lang} to activate

Scripts Support: When WITH_SCRIPTS=yes is used, a shared scripts directory is created at skills/scripts/{skill-name}/. This allows:

• Multi-language skills to share the same executable scripts
• Scripts referenced via relative path scripts/ in skill documentation
• Automatic linking/copying of scripts during setup for both Unix/Mac (symlink) and Windows (copy)

Create a New MCP Service

# Create a new MCP service
make init-mcp SERVICE=mcp-foo

After creation:

1. Navigate to mcp/mcp-foo/
2. Implement your MCP service
3. Add a Makefile with build, test, and clean targets

Manage Skills in Agents

# Add a skill to an agent (English)
make add-skill AGENT=my-agent SKILL=testing

# Add a skill to a Chinese agent
make add-skill AGENT=my-agent SKILL=testing LANG=zh-cn

This automatically updates the agent's frontmatter to include the specified skill.

Build and Test

# Build a single MCP service
make build SERVICE=mcp-foo

# Build all MCP services
make build-all

# Test all MCP services
make test-all

# Clean all MCP service artifacts
make clean-all

# Build the mindforge CLI (Go)
make cli

# Vet + test the CLI
make cli-test

Note: Agents and skills are markdown files and don't require building. Default writing hooks are tested with python3 hooks/test_scheme_a.py and bash hooks/test-inject-style-rules.sh; optional terminology utilities retain separate Python tests.

📋 Resource Conventions

Each MCP service, Agent, or Skill should provide its own Makefile with at least the following targets:

• build - Build the resource
• test - Test the resource
• clean - Clean build artifacts

Optional targets:

• fmt - Format code
• lint - Lint code

Each resource can use its own technology stack (Go/Node/Python/Rust/etc.)

🧰 Tech Stack

• MCP Services: Any language and framework that supports the MCP protocol
• Agents: AI agents for executing specific tasks
• Skills: Reusable capability modules that can be referenced by agents

🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

1. Fork the repository
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add some amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

• Built for Claude Code
• Supports the Model Context Protocol (MCP)

📞 Support

If you encounter any issues or have questions, please open an issue on GitHub.

Made with ❤️ by the MindForge community