diff --git a/docs.json b/docs.json index 9d39ee9..0e2d1fd 100644 --- a/docs.json +++ b/docs.json @@ -159,6 +159,7 @@ "group": "Setup", "icon": "settings", "pages": [ + "mcp/agents", "mcp/cursor", "mcp/claude-code", "mcp/devin-desktop", diff --git a/mcp/agents.mdx b/mcp/agents.mdx new file mode 100644 index 0000000..03871c5 --- /dev/null +++ b/mcp/agents.mdx @@ -0,0 +1,1184 @@ +--- +title: "Every Supported Agent" +description: "The full list of AI coding agents and IDEs summer setup can configure for Summer Engine, with the exact MCP config file, file shape, and skills folder each one uses." +icon: "list" +--- + +{/* Generated from the toolkit's agent table (src/installer/agent-table.ts in SummerEngine/summer) on 2026-09-11. Regenerate rather than hand-edit the per-agent sections; the prose above the first agent is hand-written. */} + +One command configures any of these agents: + +```bash +npx -y summer-engine@latest setup --yes +``` + +It writes the MCP server entry into the agent's own config file, installs the Summer skill library where that agent reads skills, and runs `summer doctor`. Every path below is what the command writes; paste the snippet yourself if you prefer to edit files by hand. Paths were checked against each product's official documentation on 2026-09-11. Where a vendor's docs are ambiguous, the section says so. + +**31 active agents.** Agents marked legacy still work but warn on use. + +Add `--scope project` to write the project-level file instead of the user-level one where the agent has one. Add `--print` to see the snippet without writing anything, `--dry-run` to see the plan. `--channel next` points the entry at a pre-release build. + + +**One skills folder for most agents.** Codex, Cursor, Zed, OpenCode, Copilot in VS Code, Devin Desktop, Amp, Crush, Warp, Kimi Code, Factory Droid, Rovo Dev and Grok Build all read the agentskills.io folder `~/.agents/skills` (and `.agents/skills` inside a project). Setting up any one of them installs the skills for all of them. See [Skills](/mcp/skills). + + +## Claude Code + +Full guide: [Claude Code](/mcp/claude-code). The essentials: + +```bash +npx -y summer-engine@latest setup claude-code --yes +``` + +Id: `claude-code`. Also accepted: `claude`. + +| | | +|---|---| +| MCP config (user) | `~/.claude.json` · Windows `%USERPROFILE%\.claude.json` | +| MCP config (project) | `.mcp.json` | +| Skills (user) | `~/.claude/skills` | +| Skills (project) | `.claude/skills` | +| After setup | Restart Claude Code or run /mcp in a new session. | + +What `summer setup` writes (paste this if you configure by hand): + +```json ~/.claude.json +{ + "mcpServers": { + "summer-engine": { + "type": "stdio", + "command": "npx", + "args": [ + "-y", + "summer-engine@latest", + "mcp" + ] + } + } +} +``` + +## Claude Desktop + +```bash +npx -y summer-engine@latest setup claude-desktop --yes +``` + +Id: `claude-desktop`. Also accepted: `claude-app`, `claudedesktop`. + +| | | +|---|---| +| MCP config (user) | `~/Library/Application Support/Claude/claude_desktop_config.json` · Linux `~/.config/Claude/claude_desktop_config.json` · Windows `%APPDATA%\Claude\claude_desktop_config.json` | +| MCP config (project) | none; a `--scope project` request writes the user file with a warning | +| Skills | none. Claude Desktop has no skills folder. The MCP server ships summer_get_agent_playbook, so the model can pull Summer guidance in-chat. | +| After setup | Quit and reopen Claude Desktop; the summer-engine tools appear under the tools menu in a new chat. | + +What `summer setup` writes (paste this if you configure by hand): + +```json ~/Library/Application Support/Claude/claude_desktop_config.json +{ + "mcpServers": { + "summer-engine": { + "command": "npx", + "args": [ + "-y", + "summer-engine@latest", + "mcp" + ] + } + } +} +``` + +## Codex + +Full guide: [Codex](/mcp/codex). The essentials: + +```bash +npx -y summer-engine@latest setup codex --yes +``` + +Id: `codex`. Also accepted: `codex-cli`, `openai-codex`. + +| | | +|---|---| +| MCP config (user) | `~/.codex/config.toml` · Windows `%USERPROFILE%\.codex\config.toml` | +| MCP config (project) | `.codex/config.toml` | +| Note | Codex only loads project .codex/config.toml from trusted projects. | +| Skills (user) | `~/.agents/skills` — the shared agentskills.io folder | +| Skills (project) | `.agents/skills` | +| After setup | Restart Codex or run /mcp in a new session. | + +What `summer setup` writes (paste this if you configure by hand): + +```toml ~/.codex/config.toml +[mcp_servers.summer-engine] +command = "npx" +args = ["-y", "summer-engine@latest", "mcp"] +``` + +## Cursor + +Full guide: [Cursor](/mcp/cursor). The essentials: + +```bash +npx -y summer-engine@latest setup cursor --yes +``` + +Id: `cursor`. + +| | | +|---|---| +| MCP config (user) | `~/.cursor/mcp.json` · Windows `%USERPROFILE%\.cursor\mcp.json` | +| MCP config (project) | `.cursor/mcp.json` | +| Skills (user) | `~/.agents/skills` — the shared agentskills.io folder | +| Skills (project) | `.agents/skills` | +| After setup | Restart Cursor and enable the summer-engine MCP server if prompted. | + +What `summer setup` writes (paste this if you configure by hand): + +```json ~/.cursor/mcp.json +{ + "mcpServers": { + "summer-engine": { + "type": "stdio", + "command": "npx", + "args": [ + "-y", + "summer-engine@latest", + "mcp" + ] + } + } +} +``` + +## Devin Desktop (formerly Windsurf) + +Full guide: [Devin Desktop (formerly Windsurf)](/mcp/devin-desktop). The essentials: + +```bash +npx -y summer-engine@latest setup windsurf --yes +``` + +Id: `windsurf`. Also accepted: `devin`, `devin-desktop`, `devindesktop`. + +| | | +|---|---| +| MCP config (user) | `~/.codeium/windsurf/mcp_config.json` · Windows `%USERPROFILE%\.codeium\windsurf\mcp_config.json` | +| MCP config (project) | none; a `--scope project` request writes the user file with a warning | +| Skills (user) | `~/.agents/skills` — the shared agentskills.io folder | +| Skills (project) | `.agents/skills` | +| After setup | Restart Devin Desktop (formerly Windsurf) and refresh MCP servers from the agent settings. Devin's docs say mcp_config.json configures the Cascade agent; for the Devin agent add the server in the app's MCP settings with the same command. | + + +Devin's docs say `mcp_config.json` configures the Cascade agent. For the Devin agent, add the same command in the app's MCP settings. + + +What `summer setup` writes (paste this if you configure by hand): + +```json ~/.codeium/windsurf/mcp_config.json +{ + "mcpServers": { + "summer-engine": { + "command": "npx", + "args": [ + "-y", + "summer-engine@latest", + "mcp" + ] + } + } +} +``` + +## Antigravity + +Full guide: [Antigravity](/mcp/antigravity). The essentials: + +```bash +npx -y summer-engine@latest setup antigravity --yes +``` + +Id: `antigravity`. Also accepted: `agy`, `google-antigravity`. + +| | | +|---|---| +| MCP config (user) | `~/.gemini/config/mcp_config.json` · Windows `%USERPROFILE%\.gemini\config\mcp_config.json` | +| MCP config (project) | `.agents/mcp_config.json` | +| Skills (user) | `~/.gemini/config/skills` | +| Skills (project) | `.agents/skills` | +| After setup | In Antigravity open the agent panel's MCP servers view and refresh; summer-engine appears in the list (IDE and CLI share this file). | + +What `summer setup` writes (paste this if you configure by hand): + +```json ~/.gemini/config/mcp_config.json +{ + "mcpServers": { + "summer-engine": { + "command": "npx", + "args": [ + "-y", + "summer-engine@latest", + "mcp" + ] + } + } +} +``` + +## Cline (VS Code) + +```bash +npx -y summer-engine@latest setup cline --yes +``` + +Id: `cline`. Also accepted: `cline-vscode`. + +| | | +|---|---| +| MCP config (user) | `~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json` · Linux `~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json` · Windows `%APPDATA%\Code\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json` | +| MCP config (project) | none; a `--scope project` request writes the user file with a warning | +| Skills (user) | `~/.cline/skills` | +| Skills (project) | `.cline/skills` | +| After setup | Restart VS Code so Cline reloads its MCP config. | + +What `summer setup` writes (paste this if you configure by hand): + +```json ~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json +{ + "mcpServers": { + "summer-engine": { + "command": "npx", + "args": [ + "-y", + "summer-engine@latest", + "mcp" + ] + } + } +} +``` + +## Cline CLI + +```bash +npx -y summer-engine@latest setup cline-cli --yes +``` + +Id: `cline-cli`. Also accepted: `clinecli`. + +| | | +|---|---| +| MCP config (user) | `~/.cline/data/settings/cline_mcp_settings.json` · Windows `%USERPROFILE%\.cline\data\settings\cline_mcp_settings.json` | +| MCP config (project) | none; a `--scope project` request writes the user file with a warning | +| Skills (user) | `~/.cline/skills` | +| Skills (project) | `.cline/skills` | +| After setup | Restart the Cline CLI so it reloads its MCP settings. | + + +Cline's own docs name two files for the CLI (`~/.cline/mcp.json` and `~/.cline/data/settings/cline_mcp_settings.json`). Summer writes the one from the CLI configuration page. + + +What `summer setup` writes (paste this if you configure by hand): + +```json ~/.cline/data/settings/cline_mcp_settings.json +{ + "mcpServers": { + "summer-engine": { + "command": "npx", + "args": [ + "-y", + "summer-engine@latest", + "mcp" + ] + } + } +} +``` + +## Kilo Code + +```bash +npx -y summer-engine@latest setup kilo-code --yes +``` + +Id: `kilo-code`. Also accepted: `kilo`, `kilocode`. + +| | | +|---|---| +| MCP config (user) | `~/.config/kilo/kilo.json` · Windows `%APPDATA%\kilo\kilo.json` | +| MCP config (project) | `kilo.json` | +| Skills (user) | `~/.kilo/skills` | +| Skills (project) | `.kilo/skills` | +| After setup | Restart Kilo (CLI or the VS Code extension) so it reloads kilo.json. | + +What `summer setup` writes (paste this if you configure by hand): + +```json ~/.config/kilo/kilo.json +{ + "mcp": { + "summer-engine": { + "type": "local", + "command": [ + "npx", + "-y", + "summer-engine@latest", + "mcp" + ], + "enabled": true + } + } +} +``` + +## GitHub Copilot CLI + +Full guide: [GitHub Copilot CLI](/mcp/github-copilot). The essentials: + +```bash +npx -y summer-engine@latest setup github-copilot --yes +``` + +Id: `github-copilot`. Also accepted: `copilot`, `copilot-cli`, `github-copilot-cli`. + +| | | +|---|---| +| MCP config (user) | `~/.copilot/mcp-config.json` · Windows `%USERPROFILE%\.copilot\mcp-config.json` | +| MCP config (project) | `.mcp.json` | +| Skills (user) | `~/.copilot/skills` | +| Skills (project) | `.github/skills` | +| After setup | Restart Copilot CLI, or run /mcp reload and /skills reload in the active session. | + +What `summer setup` writes (paste this if you configure by hand): + +```json ~/.copilot/mcp-config.json +{ + "mcpServers": { + "summer-engine": { + "type": "local", + "command": "npx", + "args": [ + "-y", + "summer-engine@latest", + "mcp" + ], + "tools": [ + "*" + ] + } + } +} +``` + +## GitHub Copilot in VS Code + +Full guide: [GitHub Copilot in VS Code](/mcp/vscode). The essentials: + +```bash +npx -y summer-engine@latest setup vscode-copilot --yes +``` + +Id: `vscode-copilot`. Also accepted: `vscode`, `vs-code`, `vs-code-copilot`, `github-copilot-vscode`. + +| | | +|---|---| +| MCP config (user) | `~/Library/Application Support/Code/User/mcp.json` · Linux `~/.config/Code/User/mcp.json` · Windows `%APPDATA%\Code\User\mcp.json` | +| MCP config (project) | `.vscode/mcp.json` | +| Skills (user) | `~/.agents/skills` — the shared agentskills.io folder | +| Skills (project) | `.agents/skills` | +| After setup | Restart VS Code or run MCP: List Servers, then start summer-engine in Copilot Agent mode. | + +What `summer setup` writes (paste this if you configure by hand): + +```json ~/Library/Application Support/Code/User/mcp.json +{ + "servers": { + "summer-engine": { + "type": "stdio", + "command": "npx", + "args": [ + "-y", + "summer-engine@latest", + "mcp" + ] + } + } +} +``` + +## GitHub Copilot in Visual Studio + +```bash +npx -y summer-engine@latest setup visual-studio --yes +``` + +Id: `visual-studio`. Also accepted: `vs`, `vs2026`, `visual-studio-2026`, `visualstudio`. + +| | | +|---|---| +| MCP config (user) | `~/.mcp.json` · Windows `%USERPROFILE%\.mcp.json` | +| MCP config (project) | `.mcp.json` | +| Skills | none. Visual Studio's Copilot has no skills folder yet; the MCP server ships summer_get_agent_playbook for in-chat guidance. | +| After setup | Restart Visual Studio, open Copilot Chat in Agent mode, and enable summer-engine in the tools picker. | + + +Visual Studio also reads `.vs/mcp.json`, `.vscode/mcp.json` and `.cursor/mcp.json` in the solution folder. + + +What `summer setup` writes (paste this if you configure by hand): + +```json ~/.mcp.json +{ + "servers": { + "summer-engine": { + "type": "stdio", + "command": "npx", + "args": [ + "-y", + "summer-engine@latest", + "mcp" + ] + } + } +} +``` + +## GitHub Copilot in JetBrains IDEs + +```bash +npx -y summer-engine@latest setup copilot-jetbrains --yes +``` + +Id: `copilot-jetbrains`. Also accepted: `jetbrains-copilot`, `intellij-copilot`, `copilot-intellij`. + +| | | +|---|---| +| MCP config (user) | `~/.config/github-copilot/intellij/mcp.json` · Windows `%APPDATA%\github-copilot\intellij\mcp.json` | +| MCP config (project) | none; a `--scope project` request writes the user file with a warning | +| Skills | none. Copilot in JetBrains documents no skills folder; the MCP server ships summer_get_agent_playbook for in-chat guidance. | +| After setup | Restart the JetBrains IDE and open Copilot Chat in Agent mode; summer-engine shows in the tools list. | + + +The user config path comes from Microsoft's Copilot for JetBrains feedback repository, not from docs.github.com, which only says the file opens from Settings. + + +What `summer setup` writes (paste this if you configure by hand): + +```json ~/.config/github-copilot/intellij/mcp.json +{ + "servers": { + "summer-engine": { + "command": "npx", + "args": [ + "-y", + "summer-engine@latest", + "mcp" + ] + } + } +} +``` + +## OpenCode + +Full guide: [OpenCode](/mcp/opencode). The essentials: + +```bash +npx -y summer-engine@latest setup opencode --yes +``` + +Id: `opencode`. Also accepted: `open-code`. + +| | | +|---|---| +| MCP config (user) | `~/.config/opencode/opencode.json` · Windows `%APPDATA%\opencode\opencode.json` | +| MCP config (project) | `opencode.json` | +| Skills (user) | `~/.agents/skills` — the shared agentskills.io folder | +| Skills (project) | `.agents/skills` | +| After setup | Restart OpenCode so it reloads opencode.json. | + +What `summer setup` writes (paste this if you configure by hand): + +```json ~/.config/opencode/opencode.json +{ + "$schema": "https://opencode.ai/config.json", + "mcp": { + "summer-engine": { + "type": "local", + "command": [ + "npx", + "-y", + "summer-engine@latest", + "mcp" + ], + "enabled": true + } + } +} +``` + +## Zed + +Full guide: [Zed](/mcp/zed). The essentials: + +```bash +npx -y summer-engine@latest setup zed --yes +``` + +Id: `zed`. Also accepted: `zed-editor`. + +| | | +|---|---| +| MCP config (user) | `~/.config/zed/settings.json` · Windows `%APPDATA%\zed\settings.json` | +| MCP config (project) | none; a `--scope project` request writes the user file with a warning | +| Skills (user) | `~/.agents/skills` — the shared agentskills.io folder | +| Skills (project) | `.agents/skills` | +| After setup | Zed reloads settings.json live; open the Agent panel and check summer-engine under MCP servers. | + +What `summer setup` writes (paste this if you configure by hand): + +```json ~/.config/zed/settings.json +{ + "context_servers": { + "summer-engine": { + "command": "npx", + "args": [ + "-y", + "summer-engine@latest", + "mcp" + ], + "env": {} + } + } +} +``` + +## Kiro + +```bash +npx -y summer-engine@latest setup kiro --yes +``` + +Id: `kiro`. Also accepted: `kiro-ide`, `aws-kiro`. + +| | | +|---|---| +| MCP config (user) | `~/.kiro/settings/mcp.json` · Windows `%USERPROFILE%\.kiro\settings\mcp.json` | +| MCP config (project) | `.kiro/settings/mcp.json` | +| Skills (user) | `~/.kiro/skills` | +| Skills (project) | `.kiro/skills` | +| After setup | Kiro reloads MCP config on save; open the MCP Servers view to confirm summer-engine is connected. | + +What `summer setup` writes (paste this if you configure by hand): + +```json ~/.kiro/settings/mcp.json +{ + "mcpServers": { + "summer-engine": { + "command": "npx", + "args": [ + "-y", + "summer-engine@latest", + "mcp" + ] + } + } +} +``` + +## Goose + +Full guide: [Goose](/mcp/local-models). The essentials: + +```bash +npx -y summer-engine@latest setup goose --yes +``` + +Id: `goose`. Also accepted: `block-goose`, `codename-goose`. + +| | | +|---|---| +| MCP config (user) | `~/.config/goose/config.yaml` · Windows `%APPDATA%\Block\goose\config\config.yaml` | +| MCP config (project) | none; a `--scope project` request writes the user file with a warning | +| Skills (user) | `~/.config/agents/skills` | +| Skills (project) | `.agents/skills` | +| After setup | Restart Goose (CLI or Desktop); summer-engine is listed under Extensions. | + +What `summer setup` writes (paste this if you configure by hand): + +```yaml ~/.config/goose/config.yaml +extensions: + summer-engine: + type: stdio + name: summer-engine + description: "Summer Engine: scenes, scripts, play mode and diagnostics over MCP" + cmd: npx + args: + - -y + - summer-engine@latest + - mcp + enabled: true + timeout: 300 + env_keys: [] + envs: {} +``` + +## Hermes Agent + +```bash +npx -y summer-engine@latest setup hermes --yes +``` + +Id: `hermes`. Also accepted: `hermes-agent`, `nous-hermes`. + +| | | +|---|---| +| MCP config (user) | `~/.hermes/config.yaml` · Windows `%USERPROFILE%\.hermes\config.yaml` | +| MCP config (project) | none; a `--scope project` request writes the user file with a warning | +| Skills (user) | `~/.hermes/skills` | +| Skills (project) | `.agents/skills` | +| After setup | Run /reload-mcp in Hermes Agent (or restart it). | + +What `summer setup` writes (paste this if you configure by hand): + +```yaml ~/.hermes/config.yaml +mcp_servers: + summer-engine: + command: npx + args: + - -y + - summer-engine@latest + - mcp +``` + +## Trae + +```bash +npx -y summer-engine@latest setup trae --yes +``` + +Id: `trae`. Also accepted: `trae-ide`, `bytedance-trae`. + +| | | +|---|---| +| MCP config (user) | none: Trae manages user-level MCP servers in its UI; writing the project file .trae/mcp.json instead. | +| MCP config (project) | `.trae/mcp.json` | +| Skills | none. Trae documents no skills folder; the MCP server ships summer_get_agent_playbook for in-chat guidance. | +| After setup | Restart Trae and open the MCP settings; summer-engine should show as connected. | + + +Trae keeps user-level MCP servers in its UI, so Summer only writes the project file. + + +What `summer setup` writes (paste this if you configure by hand): + +```json .trae/mcp.json +{ + "mcpServers": { + "summer-engine": { + "command": "npx", + "args": [ + "-y", + "summer-engine@latest", + "mcp" + ] + } + } +} +``` + +## Qwen Code + +```bash +npx -y summer-engine@latest setup qwen-code --yes +``` + +Id: `qwen-code`. Also accepted: `qwen`, `qwencode`. + +| | | +|---|---| +| MCP config (user) | `~/.qwen/settings.json` · Windows `%USERPROFILE%\.qwen\settings.json` | +| MCP config (project) | `.qwen/settings.json` | +| Skills (user) | `~/.qwen/skills` | +| Skills (project) | `.qwen/skills` | +| After setup | Restart Qwen Code or run /mcp in a new session. | + +What `summer setup` writes (paste this if you configure by hand): + +```json ~/.qwen/settings.json +{ + "mcpServers": { + "summer-engine": { + "command": "npx", + "args": [ + "-y", + "summer-engine@latest", + "mcp" + ] + } + } +} +``` + +## Kimi Code CLI + +```bash +npx -y summer-engine@latest setup kimi-code --yes +``` + +Id: `kimi-code`. Also accepted: `kimi`, `kimi-cli`, `kimicode`. + +| | | +|---|---| +| MCP config (user) | `~/.kimi-code/mcp.json` · Windows `%USERPROFILE%\.kimi-code\mcp.json` | +| MCP config (project) | `.kimi-code/mcp.json` | +| Skills (user) | `~/.agents/skills` — the shared agentskills.io folder | +| Skills (project) | `.agents/skills` | +| After setup | Restart Kimi Code CLI so it reconnects its MCP servers. | + +What `summer setup` writes (paste this if you configure by hand): + +```json ~/.kimi-code/mcp.json +{ + "mcpServers": { + "summer-engine": { + "command": "npx", + "args": [ + "-y", + "summer-engine@latest", + "mcp" + ] + } + } +} +``` + +## Crush + +```bash +npx -y summer-engine@latest setup crush --yes +``` + +Id: `crush`. Also accepted: `charm-crush`. + +| | | +|---|---| +| MCP config (user) | `~/.config/crush/crushrc` · Windows `%USERPROFILE%\.config\crush\crushrc` | +| MCP config (project) | `.crushrc` | +| Skills (user) | `~/.agents/skills` — the shared agentskills.io folder | +| Skills (project) | `.agents/skills` | +| After setup | Restart Crush so it reloads crushrc. | + +What `summer setup` writes (paste this if you configure by hand): + +```json ~/.config/crush/crushrc +{ + "mcp": { + "summer-engine": { + "type": "stdio", + "command": "npx", + "args": [ + "-y", + "summer-engine@latest", + "mcp" + ] + } + } +} +``` + +## Amp + +```bash +npx -y summer-engine@latest setup amp --yes +``` + +Id: `amp`. Also accepted: `sourcegraph-amp`, `ampcode`. + +| | | +|---|---| +| MCP config (user) | `~/.config/amp/settings.json` · Windows `%APPDATA%\amp\settings.json` | +| MCP config (project) | none; a `--scope project` request writes the user file with a warning | +| Skills (user) | `~/.agents/skills` — the shared agentskills.io folder | +| Skills (project) | `.agents/skills` | +| After setup | Restart Amp so it reloads settings.json. | + +What `summer setup` writes (paste this if you configure by hand): + +```json ~/.config/amp/settings.json +{ + "amp.mcpServers": { + "summer-engine": { + "command": "npx", + "args": [ + "-y", + "summer-engine@latest", + "mcp" + ] + } + } +} +``` + +## Factory Droid + +```bash +npx -y summer-engine@latest setup factory --yes +``` + +Id: `factory`. Also accepted: `droid`, `factory-droid`. + +| | | +|---|---| +| MCP config (user) | `~/.factory/mcp.json` · Windows `%USERPROFILE%\.factory\mcp.json` | +| MCP config (project) | `.factory/mcp.json` | +| Skills (user) | `~/.agents/skills` — the shared agentskills.io folder | +| Skills (project) | `.agents/skills` | +| After setup | Restart droid or run /mcp in the active session. | + +What `summer setup` writes (paste this if you configure by hand): + +```json ~/.factory/mcp.json +{ + "mcpServers": { + "summer-engine": { + "type": "stdio", + "command": "npx", + "args": [ + "-y", + "summer-engine@latest", + "mcp" + ] + } + } +} +``` + +## Junie + +```bash +npx -y summer-engine@latest setup junie --yes +``` + +Id: `junie`. Also accepted: `jetbrains-junie`. + +| | | +|---|---| +| MCP config (user) | `~/.junie/mcp/mcp.json` · Windows `%USERPROFILE%\.junie\mcp\mcp.json` | +| MCP config (project) | `.junie/mcp/mcp.json` | +| Skills | none. Junie has no skills folder; put project guidance in .junie/guidelines.md. The MCP server ships summer_get_agent_playbook for in-chat guidance. | +| After setup | Restart the JetBrains IDE so Junie reloads its MCP config. | + +What `summer setup` writes (paste this if you configure by hand): + +```json ~/.junie/mcp/mcp.json +{ + "mcpServers": { + "summer-engine": { + "command": "npx", + "args": [ + "-y", + "summer-engine@latest", + "mcp" + ] + } + } +} +``` + +## Warp + +```bash +npx -y summer-engine@latest setup warp --yes +``` + +Id: `warp`. Also accepted: `warp-terminal`. + +| | | +|---|---| +| MCP config (user) | `~/.warp/.mcp.json` · Windows `%USERPROFILE%\.warp\.mcp.json` | +| MCP config (project) | `.warp/.mcp.json` | +| Skills (user) | `~/.agents/skills` — the shared agentskills.io folder | +| Skills (project) | `.agents/skills` | +| After setup | Warp detects the file and spawns the server; check Settings > AI > MCP servers. | + +What `summer setup` writes (paste this if you configure by hand): + +```json ~/.warp/.mcp.json +{ + "mcpServers": { + "summer-engine": { + "command": "npx", + "args": [ + "-y", + "summer-engine@latest", + "mcp" + ] + } + } +} +``` + +## Rovo Dev CLI + +```bash +npx -y summer-engine@latest setup rovo-dev --yes +``` + +Id: `rovo-dev`. Also accepted: `rovodev`, `rovo`, `atlassian-rovo-dev`. + +| | | +|---|---| +| MCP config (user) | `~/.rovodev/mcp.json` · Windows `%USERPROFILE%\.rovodev\mcp.json` | +| MCP config (project) | none; a `--scope project` request writes the user file with a warning | +| Skills (user) | `~/.agents/skills` — the shared agentskills.io folder | +| Skills (project) | `.agents/skills` | +| After setup | Restart Rovo Dev CLI so it reconnects its MCP servers. | + +What `summer setup` writes (paste this if you configure by hand): + +```json ~/.rovodev/mcp.json +{ + "mcpServers": { + "summer-engine": { + "command": "npx", + "args": [ + "-y", + "summer-engine@latest", + "mcp" + ], + "transport": "stdio" + } + } +} +``` + +## Qoder CLI + +```bash +npx -y summer-engine@latest setup qoder --yes +``` + +Id: `qoder`. Also accepted: `qoder-cli`. + +| | | +|---|---| +| MCP config (user) | `~/.qoder/settings.json` · Windows `%USERPROFILE%\.qoder\settings.json` | +| MCP config (project) | `.mcp.json` | +| Skills (user) | `~/.qoder/skills` | +| Skills (project) | `.qoder/skills` | +| After setup | Restart Qoder CLI so it reloads its MCP settings (the Qoder IDE manages servers in its UI). | + +What `summer setup` writes (paste this if you configure by hand): + +```json ~/.qoder/settings.json +{ + "mcpServers": { + "summer-engine": { + "command": "npx", + "args": [ + "-y", + "summer-engine@latest", + "mcp" + ] + } + } +} +``` + +## Grok Build + +```bash +npx -y summer-engine@latest setup grok-build --yes +``` + +Id: `grok-build`. Also accepted: `grok`, `xai-grok`. + +| | | +|---|---| +| MCP config (user) | `~/.grok/config.toml` · Windows `%USERPROFILE%\.grok\config.toml` | +| MCP config (project) | `.grok/config.toml` | +| Skills (user) | `~/.agents/skills` — the shared agentskills.io folder | +| Skills (project) | `.agents/skills` | +| After setup | Restart Grok Build so it reloads config.toml (it also reads `~/.claude.json` and `.cursor/mcp.json`). | + + +Grok Build also reads `~/.claude.json`, `.cursor/mcp.json` and `.mcp.json`, so a Claude Code or Cursor setup already covers it. + + +What `summer setup` writes (paste this if you configure by hand): + +```toml ~/.grok/config.toml +[mcp_servers.summer-engine] +command = "npx" +args = ["-y", "summer-engine@latest", "mcp"] +``` + +## Mistral Vibe + +```bash +npx -y summer-engine@latest setup mistral-vibe --yes +``` + +Id: `mistral-vibe`. Also accepted: `vibe`, `mistral`. + +| | | +|---|---| +| MCP config (user) | `~/.vibe/config.toml` · Windows `%USERPROFILE%\.vibe\config.toml` | +| MCP config (project) | `.vibe/config.toml` | +| Skills (user) | `~/.vibe/skills` | +| Skills (project) | `.agents/skills` | +| After setup | Restart Vibe so it reloads config.toml. | + +What `summer setup` writes (paste this if you configure by hand): + +```toml ~/.vibe/config.toml +[[mcp_servers]] +name = "summer-engine" +transport = "stdio" +command = "npx" +args = ["-y", "summer-engine@latest", "mcp"] +``` + +## LM Studio + +Full guide: [LM Studio](/mcp/local-models). The essentials: + +```bash +npx -y summer-engine@latest setup lm-studio --yes +``` + +Id: `lm-studio`. Also accepted: `lmstudio`, `lm_studio`. + +| | | +|---|---| +| MCP config (user) | `~/.lmstudio/mcp.json` · Windows `%USERPROFILE%\.lmstudio\mcp.json` | +| MCP config (project) | none; a `--scope project` request writes the user file with a warning | +| Skills | none. LM Studio has no rules or skills folder. The MCP server ships summer_get_agent_playbook, so the model can pull Summer guidance in-chat. | +| After setup | Open LM Studio, toggle on the summer-engine MCP server in the Program tab, and raise the loaded model's context length to 32k or higher. | + +What `summer setup` writes (paste this if you configure by hand): + +```json ~/.lmstudio/mcp.json +{ + "mcpServers": { + "summer-engine": { + "command": "npx", + "args": [ + "-y", + "summer-engine@latest", + "mcp" + ] + } + } +} +``` + +## Legacy agents + +These still configure and still warn: the product was retired or shut down. + +## Gemini CLI + + +**Legacy.** Gemini CLI was retired for individual accounts on 2026-06-18 and replaced by Antigravity. Use `summer setup antigravity` unless you are on a Workspace/enterprise Gemini CLI. + + +Full guide: [Gemini CLI](/mcp/gemini). The essentials: + +```bash +npx -y summer-engine@latest setup gemini --yes +``` + +Id: `gemini`. Also accepted: `gemini-cli`. + +| | | +|---|---| +| MCP config (user) | `~/.gemini/extensions/summer-engine/gemini-extension.json` · Windows `%USERPROFILE%\.gemini\extensions\summer-engine\gemini-extension.json` | +| MCP config (project) | none; a `--scope project` request writes the user file with a warning | +| Skills (user) | `~/.gemini/extensions/summer-engine/skills` | +| Skills (project) | user folder only | +| After setup | Run `summer skills install --all --agent gemini` if skills were not installed, then restart Gemini CLI (or `gemini extensions enable summer-engine` if it is disabled). | + +What `summer setup` writes (paste this if you configure by hand): + +```json ~/.gemini/extensions/summer-engine/gemini-extension.json +{ + "name": "summer-engine", + "version": "3.1.0", + "description": "Agent tooling for Summer Engine: MCP bridge, context primer, and game-dev skills. Use with the npm CLI for skill files on disk.", + "contextFileName": "GEMINI.md", + "mcpServers": { + "summer-engine": { + "command": "npx", + "args": [ + "-y", + "summer-engine@latest", + "mcp" + ] + } + }, + "settings": [ + { + "name": "enable_pre_commit_doctor", + "description": "Block git commits when summer doctor needs attention (off by default)", + "envVar": "SUMMER_PRE_COMMIT_DOCTOR", + "sensitive": false + } + ] +} +``` + +## Roo Code + + +**Legacy.** Roo Code shut down on 2026-05-15. The extension may still run, but it is no longer maintained; consider Cline or Kilo Code. + + +```bash +npx -y summer-engine@latest setup roo-code --yes +``` + +Id: `roo-code`. Also accepted: `roo`, `roocode`. + +| | | +|---|---| +| MCP config (user) | `~/Library/Application Support/Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/cline_mcp_settings.json` · Linux `~/.config/Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/cline_mcp_settings.json` · Windows `%APPDATA%\Code\User\globalStorage\rooveterinaryinc.roo-cline\settings\cline_mcp_settings.json` | +| MCP config (project) | none; a `--scope project` request writes the user file with a warning | +| Skills (user) | `~/Documents/Roo/Rules` | +| Skills (project) | `.clinerules` | +| After setup | Restart VS Code so Roo Code reloads its MCP config. | + +What `summer setup` writes (paste this if you configure by hand): + +```json ~/Library/Application Support/Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/cline_mcp_settings.json +{ + "mcpServers": { + "summer-engine": { + "command": "npx", + "args": [ + "-y", + "summer-engine@latest", + "mcp" + ] + } + } +} +``` + +## Not supported on purpose + +Checked on 2026-09-11 and left out: + +- **OpenHands CLI**: its `[mcp] stdio_servers` inline-table array has an upstream write bug; add the server through its own `openhands` config commands. +- **Xcode's agent folders**: Apple documents the `ClaudeAgentConfig/` folder but not the file names inside it. +- **Pi**: no MCP by design. **Aider, ChatGPT desktop, Replit, Perplexity**: no user-editable stdio MCP config. +- **JetBrains AI Assistant, Android Studio, Qoder IDE, Trae user-level**: MCP servers are managed in the UI only. Paste the `mcpServers` snippet from the closest section above into the UI form. +- **Continue.dev** (shut down) and **Void** (archived). + +If your agent reads any of the files above under a different name, run `summer setup --print` and paste the output. + +--- + +Need help or have questions? Reach out to our founders at [founders@summerengine.com](mailto:founders@summerengine.com) or join our community on [Discord](https://discord.gg/yUpgtxnZky) for fast responses. diff --git a/mcp/antigravity.mdx b/mcp/antigravity.mdx index d8e9903..88ed543 100644 --- a/mcp/antigravity.mdx +++ b/mcp/antigravity.mdx @@ -14,47 +14,57 @@ This guide covers the configuration. Setup takes about a minute. ## Prerequisites -- **Antigravity**: Google's AI-powered IDE +- **Antigravity**: Google's AI-powered IDE or the `agy` CLI - **Node.js**: For running the MCP server (Node 18+) - **Summer Engine**: Installed and running with your project open ## Configuration -Antigravity uses the VS Code MCP config format. The config file is: +### Option 1: One-command setup (recommended) -- **Project-level:** `.vscode/mcp.json` in your project root -- **Global:** Use the Antigravity CLI (`antigravity --add-mcp`) if available +```bash +npx -y summer-engine@latest setup antigravity --yes +``` + +This writes the `summer-engine` server into `~/.gemini/config/mcp_config.json`, the file the Antigravity IDE, the Antigravity CLI (`agy`) and Antigravity 2.0 share, installs the skill library to `~/.gemini/config/skills/`, and runs `summer doctor`. Add `--scope project` to write `.agents/mcp_config.json` and `.agents/skills/` in the project instead. -**Config format.** Antigravity uses `servers` (not `mcpServers`). The structure matches VS Code's MCP configuration. +Coming from Gemini CLI? Gemini CLI was retired for individual accounts on 2026-06-18 and Antigravity replaced it. The Summer Gemini extension still works for Workspace and enterprise Gemini CLI users (`summer setup gemini`), but new setups should use Antigravity. -### Step 1: Create or Edit the Config File +### Option 2: Manual configuration + +Antigravity uses the `mcpServers` shape. The files are: + +- **User-level:** `~/.gemini/config/mcp_config.json` +- **Project-level:** `.agents/mcp_config.json` in the project root + +#### Step 1: Create or Edit the Config File -Create `.vscode/mcp.json` in your project root. If the file already exists (e.g., for other MCP servers), add Summer Engine to the existing `servers` object. +Create the file if it doesn't exist. If it already has other MCP servers, add Summer Engine to the existing `mcpServers` object. -### Step 2: Add Summer Engine +#### Step 2: Add Summer Engine -```json New file (.vscode/mcp.json) +```json New file (~/.gemini/config/mcp_config.json) { - "servers": { + "mcpServers": { "summer-engine": { "command": "npx", - "args": ["summer-engine", "mcp"] + "args": ["-y", "summer-engine@latest", "mcp"] } } } ``` -```json Adding to existing servers +```json Adding to existing mcpServers { - "servers": { + "mcpServers": { "other-server": { ... }, "summer-engine": { "command": "npx", - "args": ["summer-engine", "mcp"] + "args": ["-y", "summer-engine@latest", "mcp"] } } } @@ -62,9 +72,9 @@ Create `.vscode/mcp.json` in your project root. If the file already exists (e.g. -### Step 3: Restart Antigravity +### Step 3: Reload MCP servers -Close and reopen Antigravity so it loads the new MCP config. The Summer Engine MCP server starts when Antigravity starts; it connects to the engine on the first tool call. +In the agent panel open the MCP servers view and refresh, or restart Antigravity. The Summer Engine MCP server starts when Antigravity starts; it connects to the engine on the first tool call. ### Step 4: Verify @@ -96,7 +106,7 @@ Start Summer Engine and open your project. The MCP server connects to the engine ### MCP server not appearing -- **Config path:** Verify `.vscode/mcp.json` is in your project root (the folder you opened in Antigravity) +- **Config path:** Verify `~/.gemini/config/mcp_config.json` (user) or `.agents/mcp_config.json` in the project root. `.vscode/mcp.json` from older guides is VS Code's file, not Antigravity's. - **JSON validity:** Ensure no trailing commas, proper quotes, and valid JSON structure - **Restart:** Fully quit and reopen Antigravity diff --git a/mcp/claude-code.mdx b/mcp/claude-code.mdx index 609119f..a9cae75 100644 --- a/mcp/claude-code.mdx +++ b/mcp/claude-code.mdx @@ -20,27 +20,36 @@ This guide covers the configuration steps. The setup takes about a minute. ## Configuration -### Step 1: Locate the Config File +### Option 1: One-command setup (recommended) -Claude Code reads MCP servers from: +```bash +npx -y summer-engine@latest setup claude-code --yes +``` + +This writes the `summer-engine` server into `~/.claude.json` (Claude Code's user-level MCP config), installs the skill library to `~/.claude/skills/`, and runs `summer doctor`. Add `--scope project` to write `.mcp.json` in the project root and `.claude/skills/` instead, so the setup travels with the game. + +### Option 2: Manual configuration -`~/.claude/claude_code_config.json` +#### Step 1: Locate the Config File -On macOS: `~/` means your home directory (e.g., `/Users/yourname/`). -On Windows: `~/.claude/` typically maps to `%USERPROFILE%\.claude\`. +Claude Code reads MCP servers from two places: -Create the file if it doesn't exist. If you already have other MCP servers configured, you'll add Summer Engine to the existing `mcpServers` object. +- **User-level:** `~/.claude.json` (all projects). On Windows: `%USERPROFILE%\.claude.json`. +- **Project-level:** `.mcp.json` in the project root (shared with the team through version control; Claude Code asks once before loading it). -### Step 2: Add Summer Engine +Create the file if it doesn't exist. If you already have other MCP servers configured, add Summer Engine to the existing `mcpServers` object. Claude Code lists `"type": "stdio"` as required for command-based servers. + +#### Step 2: Add Summer Engine -```json New file (~/.claude/claude_code_config.json) +```json New file (.mcp.json or ~/.claude.json) { "mcpServers": { "summer-engine": { + "type": "stdio", "command": "npx", - "args": ["summer-engine", "mcp"] + "args": ["-y", "summer-engine@latest", "mcp"] } } } @@ -51,8 +60,9 @@ Create the file if it doesn't exist. If you already have other MCP servers confi "mcpServers": { "other-server": { ... }, "summer-engine": { + "type": "stdio", "command": "npx", - "args": ["summer-engine", "mcp"] + "args": ["-y", "summer-engine@latest", "mcp"] } } } @@ -60,9 +70,11 @@ Create the file if it doesn't exist. If you already have other MCP servers confi +You can also let Claude Code write it: `claude mcp add summer-engine -- npx -y summer-engine@latest mcp`. + ### Step 3: Restart Claude Code -Close and reopen Claude Code so it loads the new MCP config. The server starts when Claude Code starts; it connects to the engine on the first tool call. +Start a new Claude Code session, or run `/mcp` to reload servers. The server starts when Claude Code starts; it connects to the engine on the first tool call. ### Step 4: Verify @@ -71,7 +83,7 @@ When you start a conversation, Claude should have access to Summer Engine's tool - "Use Summer Engine to add a Camera3D to the scene" - "Get the scene tree from Summer Engine" -If Claude says it doesn't have access to Summer Engine tools, check that the config file path is correct and the JSON is valid. +If Claude says it doesn't have access to Summer Engine tools, run `/mcp` to see the server list, then check the config file path and that the JSON is valid. `summer doctor` checks the same things from the terminal. ## Using Summer Engine with Claude @@ -97,7 +109,7 @@ The MCP server couldn't connect to the engine. Start Summer Engine, open your pr ### Config not loading -- **Path:** Ensure the file is exactly `~/.claude/claude_code_config.json` (not a subfolder, not a different name) +- **Path:** Ensure the file is `~/.claude.json` (user) or `.mcp.json` in the project root (project). `~/.claude/claude_code_config.json` from older guides is not read. - **JSON:** Validate the syntax. No trailing commas, all strings in double quotes - **Restart:** Fully quit Claude Code and reopen diff --git a/mcp/cli-reference.mdx b/mcp/cli-reference.mdx index b249425..5ef33e6 100644 --- a/mcp/cli-reference.mdx +++ b/mcp/cli-reference.mdx @@ -28,20 +28,23 @@ Swap `claude-code` for any supported agent: `claude-code`, `cursor`, `codex`, `w ### summer setup -Configure Summer Engine for an AI agent and run diagnostics in one step. This is the recommended onboarding command. It writes the MCP server config for the agent, installs the recommended skills, and prints a doctor report. +Configure Summer Engine for an AI agent and run diagnostics in one step. This is the recommended onboarding command. It writes the MCP server config for the agent, installs the whole skill library where that agent reads skills, and prints a doctor report. Every agent and the files it writes: [Every Supported Agent](/mcp/agents). ```bash -summer setup [--yes] [--scope user|project] [--force] +summer setup [--yes] [--scope user|project] [--force] [--recommended] [--stable-only] [--channel ] ``` | Argument / Option | Description | |-------------------|-------------| -| `` | Agent to configure: `claude-code`, `cursor`, `codex`, `windsurf`, `cline`, `roo-code`, `kilo-code`, `gemini`, `github-copilot`, `vscode-copilot`, `opencode`, `lm-studio` | +| `` | Agent to configure: `claude-code`, `claude-desktop`, `codex`, `cursor`, `windsurf`, `antigravity`, `cline`, `cline-cli`, `kilo-code`, `github-copilot`, `vscode-copilot`, `visual-studio`, `copilot-jetbrains`, `opencode`, `zed`, `kiro`, `goose`, `hermes`, `trae`, `qwen-code`, `kimi-code`, `crush`, `amp`, `factory`, `junie`, `warp`, `rovo-dev`, `qoder`, `grok-build`, `mistral-vibe`, `lm-studio`. Legacy, still accepted: `gemini`, `roo-code`. Aliases such as `claude`, `devin`, `agy`, `copilot`, `droid` resolve too | | `--yes` | Apply the practical setup steps (including skill install) without prompting | | `--scope ` | Config scope: `user` (default) or `project` | | `--dry-run` | Show planned changes without writing files | | `--print` | Print the MCP config snippet instead of writing files | -| `--force` | Overwrite existing skill content | +| `--force` | Rewrite every installed skill and remove copies older Summer versions wrote elsewhere | +| `--recommended` | Install only the recommended skill subset instead of the whole library | +| `--stable-only` | Skip skills marked preview | +| `--channel ` | npm dist-tag the MCP entry runs (`latest` by default; `next` while a release soaks) | | `--json` | Print the setup result as JSON | **Examples:** @@ -49,7 +52,8 @@ summer setup [--yes] [--scope user|project] [--force] ```bash npx -y summer-engine@latest setup claude-code --yes npx -y summer-engine@latest setup cursor --yes --scope project -npx -y summer-engine@latest setup gemini --print # See the config without writing +npx -y summer-engine@latest setup zed --print # See the config without writing +npx -y summer-engine@latest setup goose --yes # YAML config, written in place ``` --- @@ -312,6 +316,7 @@ Install and manage best-practice guides for AI agents building games. Skills are ```bash summer skills list # List available skills +summer skills list --by-domain # Grouped by primary domain summer skills install --agent # Install one skill for an agent summer skills install --recommended --agent # Install the recommended set summer skills install --all --agent # Install every skill @@ -320,12 +325,14 @@ summer skills info # Show description and preview | Option | Description | |--------|-------------| -| `--agent ` | Target agent (e.g. `claude-code`, `cursor`, `codex`) so the skill installs where that agent auto-discovers it | +| `--agent ` | Target agent (any id from `summer setup`, or `summer` for `~/.summer/skills`) so the skill installs where that agent auto-discovers it | +| `--scope ` | `user` (default) or `project` | +| `--stable-only` | With `--all` / `--recommended`, skip skills marked preview | | `--recommended` | Install the recommended skill set | | `--all` | Install every available skill | | `--force` | Overwrite existing skill content on re-install | -Most users never call this directly: `summer setup --yes` installs the recommended skills for you. See [Skills](/mcp/skills) for the full catalog and the 20+ categories. +Most users never call this directly: `summer setup --yes` installs the whole library for you. See [Skills](/mcp/skills) for the catalog and where each agent reads skills. --- @@ -351,6 +358,8 @@ to `6550` when that file is absent. | `~/.summer/api-port` | Port override if the default 6550 is occupied | | `~/.summer/cloud-token` | Summer Cloud token (from `summer login`) | | `.summer/` | Per-project durable memory (game brief, bibles, locked facts) | +| `~/.agents/skills/` | Shared agentskills.io skills folder, read by Codex, Cursor, Zed, OpenCode, Copilot in VS Code, Devin Desktop and others (`.agents/skills/` in a project) | +| `/.summer-version` | Marker `summer doctor` uses to detect stale skills | | `summer-cloud.json` | Per-project Summer Cloud binding (from `summer cloud init`) | --- diff --git a/mcp/cli.mdx b/mcp/cli.mdx index 4b5271f..eecfac4 100644 --- a/mcp/cli.mdx +++ b/mcp/cli.mdx @@ -51,7 +51,7 @@ Add this to your IDE's MCP config. The IDE spawns `summer mcp` when it connects. "mcpServers": { "summer-engine": { "command": "npx", - "args": ["summer-engine", "mcp"] + "args": ["-y", "summer-engine@latest", "mcp"] } } } diff --git a/mcp/codex.mdx b/mcp/codex.mdx index 9ded43f..3beaa39 100644 --- a/mcp/codex.mdx +++ b/mcp/codex.mdx @@ -12,6 +12,10 @@ Codex is OpenAI's AI coding assistant that supports MCP (Model Context Protocol) This guide covers the configuration. Setup takes about a minute. + +**Fastest path.** `npx -y summer-engine@latest setup codex --yes` writes the config below into `~/.codex/config.toml`, installs the skill library to `~/.agents/skills`, and runs `summer doctor`. The steps that follow are the manual version of the same thing. + + ## Prerequisites - **Codex**: OpenAI's AI coding assistant (CLI or IDE extension) @@ -44,7 +48,7 @@ Create or edit `~/.codex/config.toml` and add: ```toml New file (~/.codex/config.toml) [mcp_servers.summer-engine] command = "npx" -args = ["summer-engine", "mcp"] +args = ["-y", "summer-engine@latest", "mcp"] ``` ```toml Adding to existing config @@ -54,7 +58,7 @@ args = ["-y", "@some/other-mcp"] [mcp_servers.summer-engine] command = "npx" -args = ["summer-engine", "mcp"] +args = ["-y", "summer-engine@latest", "mcp"] ``` diff --git a/mcp/cursor.mdx b/mcp/cursor.mdx index 43f9a05..fd57ef3 100644 --- a/mcp/cursor.mdx +++ b/mcp/cursor.mdx @@ -12,6 +12,10 @@ Cursor is the most popular IDE for AI-assisted development. With Summer Engine's This guide walks you through two setup options: a one-click install link (when supported) and manual configuration, which always works. + +**Fastest path.** `npx -y summer-engine@latest setup cursor --yes` writes the config below into `~/.cursor/mcp.json`, installs the skill library to `~/.agents/skills (Cursor reads the agentskills.io folder)`, and runs `summer doctor`. The steps that follow are the manual version of the same thing. + + ## Option 1: One-Click Install Cursor supports MCP install deeplinks. Click the link below to add Summer Engine to your MCP servers: @@ -19,7 +23,7 @@ Cursor supports MCP install deeplinks. Click the link below to add Summer Engine Click to install Summer Engine MCP (opens Cursor) @@ -50,7 +54,7 @@ Create the file if it doesn't exist. If it does, add the `summer-engine` entry t "mcpServers": { "summer-engine": { "command": "npx", - "args": ["summer-engine", "mcp"] + "args": ["-y", "summer-engine@latest", "mcp"] } } } @@ -62,7 +66,7 @@ Create the file if it doesn't exist. If it does, add the `summer-engine` entry t "other-server": { ... }, "summer-engine": { "command": "npx", - "args": ["summer-engine", "mcp"] + "args": ["-y", "summer-engine@latest", "mcp"] } } } diff --git a/mcp/devin-desktop.mdx b/mcp/devin-desktop.mdx index 0425175..a06939a 100644 --- a/mcp/devin-desktop.mdx +++ b/mcp/devin-desktop.mdx @@ -52,7 +52,7 @@ Or add the config manually: "mcpServers": { "summer-engine": { "command": "npx", - "args": ["summer-engine", "mcp"] + "args": ["-y", "summer-engine@latest", "mcp"] } } } @@ -64,7 +64,7 @@ Or add the config manually: "other-server": { ... }, "summer-engine": { "command": "npx", - "args": ["summer-engine", "mcp"] + "args": ["-y", "summer-engine@latest", "mcp"] } } } diff --git a/mcp/gemini.mdx b/mcp/gemini.mdx index d51591b..ee9a801 100644 --- a/mcp/gemini.mdx +++ b/mcp/gemini.mdx @@ -8,6 +8,10 @@ icon: "sparkles" ## Summer Engine in Gemini CLI + +**Legacy.** Gemini CLI was retired for individual and Google One accounts on 2026-06-18 and replaced by Antigravity. `summer setup gemini` still works and still warns; it is for Workspace and enterprise Gemini CLI users. Everyone else: [Antigravity](/mcp/antigravity). + + Gemini CLI is Google's open-source terminal agent. With Summer Engine's integration, Gemini can control your game engine: add nodes to scenes, set properties, search and import assets, generate images and 3D models, run the game, and debug, all from the terminal. Summer ships as a Gemini extension, so setup installs both the MCP bridge and a context primer (`GEMINI.md`) that teaches Gemini the Summer skills. Setup takes about a minute. diff --git a/mcp/setup.mdx b/mcp/setup.mdx index 29d7535..47a10c7 100644 --- a/mcp/setup.mdx +++ b/mcp/setup.mdx @@ -1,169 +1,173 @@ --- title: "MCP Setup" -description: "Connect Cursor, Claude Code, Devin Desktop, Antigravity, Codex, VS Code, or Zed to Summer Engine. Build games from your favorite AI-powered IDE." +description: "Connect any AI coding agent to Summer Engine with one command: Cursor, Claude Code, Codex, Devin Desktop, Antigravity, Zed, Copilot, OpenCode, Kiro, Goose and 20 more. What summer setup writes and where." icon: "settings" --- -{/* Do not reintroduce a hardcoded MCP tool count here. The tool list grows every release and a baked-in number has already gone stale twice. */} +{/* Do not reintroduce a hardcoded MCP tool count here. The tool list grows every release and a baked-in number has already gone stale twice. The agent table below is rendered from the toolkit's agent table (2026-09-11); regenerate it rather than hand-editing rows. */} -## Build Games from Your IDE +## One Command, Any Agent -Summer Engine's MCP (Model Context Protocol) integration lets you control the engine directly from Cursor, Claude Code, Devin Desktop, Antigravity, Codex, VS Code, Zed, or any MCP-compatible AI tool. Instead of switching between your IDE and the Summer Engine editor, you stay in one place: describe what you want, and the AI modifies your game scenes, adds nodes, sets up physics, and runs your project, all through natural language. - -**What this means in practice:** Open a Summer Engine project, add the MCP config to your IDE, and ask "Add a Camera3D and DirectionalLight3D to the scene." The nodes appear in the engine. Ask "Import a low-poly tree from this URL and add it to the World node." The asset downloads, imports, and lands in your scene tree. The AI has focused tools for scene manipulation, debugging, project settings, and asset import. No copy-paste, no context switching. +```bash +npx -y summer-engine@latest setup --yes +``` -## Why Use MCP? +Replace `` with the id from the table below (`cursor`, `claude-code`, `codex`, ...). The command does three things: -### One Environment, Full Control +1. **Writes the MCP server entry** into the agent's own config file, in that agent's file shape. Existing servers in the file are kept. +2. **Installs the Summer skill library** where that agent reads skills (see [Skills](/mcp/skills)). Most agents share one folder, `~/.agents/skills`, so one setup covers several agents. +3. **Runs `summer doctor`** so you see immediately whether Node, the engine and the login are in place. -You already use Cursor or Claude Code for coding. MCP extends that workflow to game development. The AI understands your Summer Engine project: it can read the scene tree, inspect properties, run the game, capture screenshots, and fix errors, all without leaving your editor. +Add `--scope project` to write project-level files that travel with the game, `--print` to see the config without writing, `--dry-run` to see the plan. Re-run with `--force` after upgrading Summer to refresh the skills. -### Same Operations as the Built-in Chat +## What You Get -The MCP tools use the same engine operations as Summer Engine's integrated chat. AddNode, SetProp, SaveScene, ImportFromUrl. They're identical. The difference is where you type: in your IDE instead of the engine's chat panel. Undo works the same. Changes are just as safe. +Summer Engine's MCP (Model Context Protocol) server lets the agent control the engine directly: read the scene tree, add nodes, set properties, import assets, run the game, capture screenshots, read errors. Instead of switching between your editor and Summer Engine, you stay in one place and describe what you want. -### Lazy Connection +The MCP tools use the same engine operations as Summer Engine's built-in chat (AddNode, SetProp, SaveScene, ImportFromUrl). The difference is where you type. Undo works the same. Changes are just as safe. -The MCP server starts immediately. It doesn't require the engine to be running upfront. When you first call a tool, it connects to the engine. If the engine isn't running, you get a clear error: "Summer Engine is not running. Open it first, or run: npx summer-engine run." Start the engine, try again, and it works. No crashes, no hanging. +**Lazy connection.** The MCP server starts immediately and connects to the engine on the first tool call. If the engine is not running you get a clear error: "Summer Engine is not running. Open it first, or run: npx summer-engine run." Start the engine, try again. ## Prerequisites -Before setting up MCP, you need: - -1. **Summer Engine**: Either the desktop app (from [summerengine.com](https://www.summerengine.com)) or installed via `npx summer-engine install` -2. **Node.js**: For running the MCP server via `npx summer-engine mcp` (Node 18+) -3. **A Summer Engine project**: Open it in the engine so the local API server is active - -The engine runs a local HTTP server on `localhost:6550` when it's open. The MCP server connects to it using a token stored in `~/.summer/api-token` (created automatically when the engine starts). No API keys to manage. It just works. - -## Quick Setup by IDE - - - - One-click or manual config. Most popular choice for AI-assisted development. - - - Add Summer Engine to Claude Code's MCP configuration. - - - Configure Devin Desktop to use Summer Engine's MCP tools. - - - Add Summer Engine to Google's AI-powered IDE. - - - Add Summer Engine to OpenAI's AI coding assistant. - - - Add Summer Engine to VS Code or GitHub Copilot. - - - Add Summer Engine to Zed's Agent Panel. - - - Ollama, LM Studio, or Goose — no AI subscription. - - +1. **Summer Engine**: the desktop app from [summerengine.com](https://www.summerengine.com) or `npx summer-engine install` +2. **Node.js 18+**: the MCP server runs with `npx` +3. **A Summer Engine project open in the engine**, so the local API server is active + +The engine runs a local HTTP server on `localhost:6550` while it is open and writes a token to `~/.summer/api-token`. No API keys to manage. + +## Supported Agents + +Every id `summer setup` accepts, with the file it writes and where the skills land. Agents with their own guide are linked; the rest are on [Every Supported Agent](/mcp/agents) with the exact snippet. + +| Agent | `summer setup` id | MCP config it writes | Skills folder | +|---|---|---|---| +| [Claude Code](/mcp/claude-code) | `claude-code` | `~/.claude.json` / `.mcp.json` (project) | `~/.claude/skills` / `.claude/skills` | +| [Claude Desktop](/mcp/agents#claude-desktop) | `claude-desktop` | `~/Library/Application Support/Claude/claude_desktop_config.json` | none (MCP only) | +| [Codex](/mcp/codex) | `codex` | `~/.codex/config.toml` / `.codex/config.toml` (project) | `~/.agents/skills` (shared) / `.agents/skills` | +| [Cursor](/mcp/cursor) | `cursor` | `~/.cursor/mcp.json` / `.cursor/mcp.json` (project) | `~/.agents/skills` (shared) / `.agents/skills` | +| [Devin Desktop (formerly Windsurf)](/mcp/devin-desktop) | `windsurf` | `~/.codeium/windsurf/mcp_config.json` | `~/.agents/skills` (shared) / `.agents/skills` | +| [Antigravity](/mcp/antigravity) | `antigravity` | `~/.gemini/config/mcp_config.json` / `.agents/mcp_config.json` (project) | `~/.gemini/config/skills` / `.agents/skills` | +| [Cline (VS Code)](/mcp/agents#cline) | `cline` | `~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json` | `~/.cline/skills` / `.cline/skills` | +| [Cline CLI](/mcp/agents#cline-cli) | `cline-cli` | `~/.cline/data/settings/cline_mcp_settings.json` | `~/.cline/skills` / `.cline/skills` | +| [Kilo Code](/mcp/agents#kilo-code) | `kilo-code` | `~/.config/kilo/kilo.json` / `kilo.json` (project) | `~/.kilo/skills` / `.kilo/skills` | +| [GitHub Copilot CLI](/mcp/github-copilot) | `github-copilot` | `~/.copilot/mcp-config.json` / `.mcp.json` (project) | `~/.copilot/skills` / `.github/skills` | +| [GitHub Copilot in VS Code](/mcp/vscode) | `vscode-copilot` | `~/Library/Application Support/Code/User/mcp.json` / `.vscode/mcp.json` (project) | `~/.agents/skills` (shared) / `.agents/skills` | +| [GitHub Copilot in Visual Studio](/mcp/agents#visual-studio) | `visual-studio` | `~/.mcp.json` / `.mcp.json` (project) | none (MCP only) | +| [GitHub Copilot in JetBrains IDEs](/mcp/agents#copilot-jetbrains) | `copilot-jetbrains` | `~/.config/github-copilot/intellij/mcp.json` | none (MCP only) | +| [OpenCode](/mcp/opencode) | `opencode` | `~/.config/opencode/opencode.json` / `opencode.json` (project) | `~/.agents/skills` (shared) / `.agents/skills` | +| [Zed](/mcp/zed) | `zed` | `~/.config/zed/settings.json` | `~/.agents/skills` (shared) / `.agents/skills` | +| [Kiro](/mcp/agents#kiro) | `kiro` | `~/.kiro/settings/mcp.json` / `.kiro/settings/mcp.json` (project) | `~/.kiro/skills` / `.kiro/skills` | +| [Goose](/mcp/local-models) | `goose` | `~/.config/goose/config.yaml` | `~/.config/agents/skills` / `.agents/skills` | +| [Hermes Agent](/mcp/agents#hermes) | `hermes` | `~/.hermes/config.yaml` | `~/.hermes/skills` / `.agents/skills` | +| [Trae](/mcp/agents#trae) | `trae` | `.trae/mcp.json` (project) | none (MCP only) | +| [Qwen Code](/mcp/agents#qwen-code) | `qwen-code` | `~/.qwen/settings.json` / `.qwen/settings.json` (project) | `~/.qwen/skills` / `.qwen/skills` | +| [Kimi Code CLI](/mcp/agents#kimi-code) | `kimi-code` | `~/.kimi-code/mcp.json` / `.kimi-code/mcp.json` (project) | `~/.agents/skills` (shared) / `.agents/skills` | +| [Crush](/mcp/agents#crush) | `crush` | `~/.config/crush/crushrc` / `.crushrc` (project) | `~/.agents/skills` (shared) / `.agents/skills` | +| [Amp](/mcp/agents#amp) | `amp` | `~/.config/amp/settings.json` | `~/.agents/skills` (shared) / `.agents/skills` | +| [Factory Droid](/mcp/agents#factory) | `factory` | `~/.factory/mcp.json` / `.factory/mcp.json` (project) | `~/.agents/skills` (shared) / `.agents/skills` | +| [Junie](/mcp/agents#junie) | `junie` | `~/.junie/mcp/mcp.json` / `.junie/mcp/mcp.json` (project) | none (MCP only) | +| [Warp](/mcp/agents#warp) | `warp` | `~/.warp/.mcp.json` / `.warp/.mcp.json` (project) | `~/.agents/skills` (shared) / `.agents/skills` | +| [Rovo Dev CLI](/mcp/agents#rovo-dev) | `rovo-dev` | `~/.rovodev/mcp.json` | `~/.agents/skills` (shared) / `.agents/skills` | +| [Qoder CLI](/mcp/agents#qoder) | `qoder` | `~/.qoder/settings.json` / `.mcp.json` (project) | `~/.qoder/skills` / `.qoder/skills` | +| [Grok Build](/mcp/agents#grok-build) | `grok-build` | `~/.grok/config.toml` / `.grok/config.toml` (project) | `~/.agents/skills` (shared) / `.agents/skills` | +| [Mistral Vibe](/mcp/agents#mistral-vibe) | `mistral-vibe` | `~/.vibe/config.toml` / `.vibe/config.toml` (project) | `~/.vibe/skills` / `.agents/skills` | +| [LM Studio](/mcp/local-models) | `lm-studio` | `~/.lmstudio/mcp.json` | none (MCP only) | + +Legacy ids still work but warn: `gemini` (Gemini CLI, retired for individual accounts on 2026-06-18; use `antigravity`) and `roo-code` (shut down 2026-05-15). + +Aliases: `claude` → `claude-code`, `devin` → `windsurf`, `agy` → `antigravity`, `copilot` → `github-copilot`, `vscode` → `vscode-copilot`, `droid` → `factory`, `kilo` → `kilo-code`, `qwen` → `qwen-code`, `kimi` → `kimi-code`. ## Manual Configuration -If your IDE supports MCP but isn't listed above, add this to your MCP config file: +If you would rather edit files yourself, or your agent is not listed, these are the shapes in use. `summer setup --print` prints the exact one for any agent. -```json Cursor (.cursor/mcp.json) +```json mcpServers (Cursor, Claude Code, Claude Desktop, Kiro, Qwen, Kimi, Warp, ...) { "mcpServers": { "summer-engine": { + "type": "stdio", "command": "npx", - "args": ["summer-engine", "mcp"] + "args": ["-y", "summer-engine@latest", "mcp"] } } } ``` -```json Claude Code (~/.claude/claude_code_config.json) +```json servers (VS Code, Visual Studio, Copilot in JetBrains) { - "mcpServers": { + "servers": { "summer-engine": { + "type": "stdio", "command": "npx", - "args": ["summer-engine", "mcp"] + "args": ["-y", "summer-engine@latest", "mcp"] } } } ``` -```json VS Code / Antigravity (.vscode/mcp.json) +```json mcp (OpenCode, Kilo Code) { - "servers": { + "mcp": { "summer-engine": { - "type": "stdio", - "command": "npx", - "args": ["summer-engine", "mcp"] + "type": "local", + "command": ["npx", "-y", "summer-engine@latest", "mcp"], + "enabled": true } } } ``` -```json Zed (context_servers in settings.json) +```json context_servers (Zed settings.json) { "context_servers": { "summer-engine": { "command": "npx", - "args": ["summer-engine", "mcp"], + "args": ["-y", "summer-engine@latest", "mcp"], "env": {} } } } ``` +```toml TOML (Codex ~/.codex/config.toml, Grok Build) +[mcp_servers.summer-engine] +command = "npx" +args = ["-y", "summer-engine@latest", "mcp"] +``` + +```yaml YAML (Goose ~/.config/goose/config.yaml) +extensions: + summer-engine: + type: stdio + name: summer-engine + cmd: npx + args: ["-y", "summer-engine@latest", "mcp"] + enabled: true + timeout: 300 +``` + -**No global install required.** Using `npx summer-engine mcp` runs the server on demand. For faster startup, you can install globally: `npm install -g summer-engine`, then use `"args": ["summer", "mcp"]` instead. +**Windows.** `npx` is a shell shim, and hosts that spawn it directly fail with ENOENT. `summer setup` writes `"command": "cmd.exe", "args": ["/c", "npx", "-y", "summer-engine@latest", "mcp"]` on Windows; do the same by hand. + + + +**No global install required.** `npx -y summer-engine@latest mcp` runs the current release on demand. For faster startup install globally (`npm install -g summer-engine`) and use `"command": "summer", "args": ["mcp"]`. ## Verify It Works -1. **Start Summer Engine**: Open your project in the engine (or run `npx summer-engine run` from the project directory). -2. **Restart your IDE**: So it picks up the new MCP config. -3. **Check the MCP panel**: In Cursor: Settings > MCP. You should see "summer-engine" connected, with its tools listed. +1. **Start Summer Engine**: open your project in the engine (or run `npx summer-engine run` from the project directory). +2. **Restart the agent** so it reloads its MCP config. `summer setup` prints the exact step for your agent. +3. **Check the MCP list**: in Cursor, Settings > MCP; in Claude Code, `/mcp`. You should see `summer-engine` connected with its tools. 4. **Ask the AI**: "Use Summer Engine to add a MeshInstance3D with a BoxMesh to the scene root. Name it TestCube." -5. **Confirm in the engine**: The node should appear in the scene tree. +5. **Confirm in the engine**: the node appears in the scene tree. -If you get "Summer Engine is not running," the engine isn't open or the project isn't loaded. Start the engine and try again. +`summer doctor` checks all of this from the terminal, including whether the agent's recorded config still points at a current Summer release. ## What the AI Can Do @@ -176,28 +180,36 @@ The MCP server exposes tools in these categories: | **Visual Verification** | Screenshot the viewport or the running game | | **Project** | Project context, settings, input mappings, scene tree, import assets from URLs | | **Project Files** | Read, write, and patch script and resource files inside the bound project | -| **Asset Library** | Search the 25k+ public library and your assets, then import | +| **Asset Library** | Search the public library and your assets, then import | | **Generation** | Generate images, 3D models, audio, video, and motion clips, slice sprite sheets, and poll job status | +| **Navigation** | Open the right page on summerengine.com or the right surface in the editor for the user (`summer_open`) | | **Summer Cloud** | Sync the project across machines: push, pull, status, restore, checkpoints, conflicts | For a full reference with parameters and examples, see the [Tools Reference](/mcp/tools-reference). For a step-by-step guide on how an AI agent builds a complete game using these tools, see [Building a Game with MCP](/mcp/building-a-game). ## Next Steps - + - Detailed Cursor configuration with one-click install + Config file, file shape and skills folder for all agents + + + The skill library and where each agent reads it - All CLI commands: install, login, run, create, and more + All CLI commands: setup, doctor, install, run, create, and more Every MCP tool with parameters and usage examples - - How an AI agent builds a full game using MCP - --- diff --git a/mcp/skills.mdx b/mcp/skills.mdx index b982174..ebd1c44 100644 --- a/mcp/skills.mdx +++ b/mcp/skills.mdx @@ -1,220 +1,297 @@ --- title: "Skills" -description: "The Summer Engine skill library: 60+ best-practice guides across 20 categories that make AI agents better at building games, from FPS controllers to asset generation to multiplayer." +description: "The Summer Engine skill library: 94 best-practice guides for AI agents building games, grouped by domain, with where each agent reads them and how to install and update them." icon: "book-open" --- +{/* The catalog and the folder table are rendered from the toolkit's generated registry (registry/generated/index.json) and agent table on 2026-09-11. Regenerate them rather than hand-editing rows. */} + ## What Are Skills? -Skills are best-practice guides that make AI agents better at game development. Each skill is a Markdown file (a `SKILL.md`) that teaches the agent a specific discipline: how to compose a scene, build an FPS controller, generate a character model, set up multiplayer, or debug a crash. When the situation matches, the agent loads the skill and follows it. +Skills are best-practice guides that make AI agents better at game development. Each skill is a folder with a `SKILL.md` that teaches the agent one discipline: composing a scene, building an FPS controller, generating a character model, setting up multiplayer, debugging a crash. The agent sees each skill's name and one-line description, and loads the full body only when the situation matches. -The library ships with the Summer CLI and covers 20 categories spanning the whole game-dev workflow. Skills follow the [Agent Skills](https://agentskills.io/) open standard, so they work with Claude Code, Cursor, Codex, Gemini CLI, GitHub Copilot, OpenCode, and other compatible agents. +Skills follow the [Agent Skills](https://agentskills.io/) open standard (`//SKILL.md`), so the same files work in every agent listed on [Every Supported Agent](/mcp/agents). The library ships inside the `summer-engine` npm package and is developed in the open at [github.com/SummerEngine/summer](https://github.com/SummerEngine/summer/tree/main/library/skills); the browsable index there is [library/skills/README.md](https://github.com/SummerEngine/summer/blob/main/library/skills/README.md). ## Quick Start -The recommended skill set installs automatically when you onboard an agent: +`summer setup` installs the whole library for the agent you name, in the same scope as the MCP config: ```bash npx -y summer-engine@latest setup claude-code --yes ``` -Or manage skills directly: +Manage skills directly: ```bash -# List available skills -summer skills list +summer skills list # every skill, one line each +summer skills list --by-domain # grouped like this page +summer skills info debug # one skill's description and body +summer skills install --all --agent cursor # every skill for an agent +summer skills install --recommended --agent codex +summer skills install fps-controller --agent claude-code +summer skills install --all --agent cursor --force # refresh after an upgrade +``` -# Install the recommended set for an agent -summer skills install --recommended --agent claude-code +- `--all` installs every skill (default for `summer setup`). `--recommended` installs the smaller starter subset marked ★ below. +- `--stable-only` skips skills marked preview. Preview means the Summer team has not yet exercised the skill in-engine; the skill's own text says so. +- `--force` rewrites every installed skill and removes the copies older Summer versions wrote elsewhere (Cursor `.mdc` rules, OpenCode `agents/summer`, per-agent folders from 3.1.0). +- `--scope project` installs into the project folder so the skills travel with the game. -# Install one skill -summer skills install fps-controller --agent cursor +## Where Skills Live -# Install every skill -summer skills install --all --agent claude-code +Most agents read the agentskills.io folder, so one install serves them all: -# Preview a skill -summer skills info debug -``` +| Agent | Skills folder (user) | Skills folder (project) | +|---|---|---| +| Codex, Cursor, Devin Desktop (formerly Windsurf), GitHub Copilot in VS Code, OpenCode, Zed, Kimi Code CLI, Crush, Amp, Factory Droid, Warp, Rovo Dev CLI, Grok Build | `~/.agents/skills` (shared) | `.agents/skills` | +| Claude Code | `~/.claude/skills` | `.claude/skills` | +| Antigravity | `~/.gemini/config/skills` | `.agents/skills` | +| Cline (VS Code) | `~/.cline/skills` | `.cline/skills` | +| Cline CLI | `~/.cline/skills` | `.cline/skills` | +| Kilo Code | `~/.kilo/skills` | `.kilo/skills` | +| GitHub Copilot CLI | `~/.copilot/skills` | `.github/skills` | +| Kiro | `~/.kiro/skills` | `.kiro/skills` | +| Goose | `~/.config/agents/skills` | `.agents/skills` | +| Hermes Agent | `~/.hermes/skills` | `.agents/skills` | +| Qwen Code | `~/.qwen/skills` | `.qwen/skills` | +| Qoder CLI | `~/.qoder/skills` | `.qoder/skills` | +| Mistral Vibe | `~/.vibe/skills` | `.agents/skills` | -## Categories +Claude Desktop, GitHub Copilot in Visual Studio, GitHub Copilot in JetBrains IDEs, Trae, Junie, LM Studio have no skills folder. They get the MCP server only; the model can pull the same guidance in-chat through the `summer_get_agent_playbook` tool. -The library is organized into 20 categories. Recommended skills install by default; the rest are available on demand. +`summer doctor` reports when installed skills are older than the CLI. Refresh with `summer setup --yes --force`. -### Workflow +## Catalog -Process disciplines that shape how the agent approaches a task before it touches code. +94 skills grouped by primary domain. ★ = in the recommended set. A skill can belong to several domains; it is listed once, under its first. + +### 2D art | Skill | Use when | |-------|----------| -| **brainstorming** | Starting a new game, mechanic, or feature; exploring intent and scope first | -| **investigating-bugs** | A first fix did not stick and you need root-cause analysis | -| **verification-before-completion** | About to claim a feature is done; forces a real check first | -| **playtesting-a-feature** | A gameplay feature is finished and needs a golden-path and edge-case playthrough | -| **writing-plans** | A multi-step spec needs a written plan with checkpoints | -| **dispatching-parallel-agents** | Two or more independent tasks can run in parallel | -| **writing-skills** | Authoring a new Summer skill | -| **debugging-game-feel** | Tuning feel ("the jump feels floaty") one variable at a time | -| **diagnosing-perf-regressions** | FPS dropped after a change and you need to bisect the cause | +| **character-portrait** ★ | Generate a single polished character bust for dialogue UI, character select, lore cards, or codex entries. One character, locked composition, VN-style. | +| **concept-art** ★ | Explore art direction with 3-4 rough concept variants of a character, environment, or prop to pick a vibe before committing to a final asset. | +| **create-asset-sheet** | Generate a pack of 2D game assets from one prompt — tile sheet, UI kit, character pack, or biome set — sliced, classified, and saved as one pack ArtAsset. | +| **instantiate-asset-pack** | Import a whole create-asset-sheet pack into the scene: groups composites, sorts paint order, emits Sprite2D/Node2D/NinePatchRect ops to lay it out. | +| **pixel-art** ★ | Generate pixel-art assets — sprites, items, tiles, portraits — at a specific resolution with pixel-perfect grid, limited palette, retro feel. | +| **skybox-panorama** | Generate a 360-degree equirectangular sky panorama and wire it as a PanoramaSkyMaterial Sky resource on WorldEnvironment in a 3D scene. | +| **sprite-sheet** | Generate animated 2D character sprites laid out as a sprite sheet — walk cycle, attack, idle, death — wired into AnimatedSprite2D / SpriteFrames. | +| **tileable-texture** | Generate a seamless tileable texture for walls, floors, or terrain — repeats cleanly on all four edges, wired as a StandardMaterial3D albedo. | +| **ui-graphics** | Generate game-UI elements — icons, buttons, panels, frames, HUD widgets, badges — flat design, transparent background, wired via TextureRect/NinePatchRect. | +| **use-widget-asset** | Wire a widget slice from a create-asset-sheet pack (panel, button, slider, bar, toggle) into NinePatchRect, TextureProgressBar, or TextureRect via sliceMeta. | + +### 3D models -### Scene and Project +| Skill | Use when | +|-------|----------| +| **character-model** ★ | Generate a rigged humanoid — player, NPC, enemy, boss — via T-pose reference, user-gated preview, and Meshy auto-rig, wired as CharacterBody3D or Node3D. | +| **environment-kit** | Generate a modular environment kit — wall pieces, floor tiles, pillars, doors, arches, corners — snap-together meshes sharing one visual style. | +| **fabricating-assets** (preview) | Fabricate meshes with a bpy script in the user's own Blender (summer_fabricate_3d) — kits with exact dimensions, VFX meshes, post-processing generated models. | +| **organic-model** | Generate organic 3D shapes — trees, rocks, mushrooms, coral, plants, vines, crystals — where AI artifacts read as natural irregularity. | +| **prop-model** ★ | Generate a single static 3D prop — sword, barrel, chest, lantern, throne, statue — one isolated object, no rigging, wired as a MeshInstance3D. | +| **vehicle-model** | Generate a hard-surface vehicle — car, spaceship, mech, boat, tank — static mesh with optional detail-texture pass, wired as Vehicle3D or MeshInstance3D. | + +### Agent workflow | Skill | Use when | |-------|----------| -| **make-game** | Building a narrow playable prototype from requirements end to end | -| **brainstorm-game** | Turning "I want to make a game" into a one-page brief at `.summer/GameSoul.md` | -| **new-project** | Starting a blank project (picks empty vs 3d-basic, opens the engine) | -| **browse-templates** | Choosing a community template to start from | -| **scene-composition** | Building scenes, organizing nodes, creating reusable prefabs | -| **play** | Running the game from a clean state and reporting whether it runs cleanly | +| **brainstorming** ★ | Explore user intent, requirements, and design before implementation — must run before any creative work: features, components, mechanics, behavior. | +| **debugging-game-feel** | Debug features that work but feel wrong — floaty jumps, mushy combat, sluggish camera — subjective bugs living in tuning, timing, and feedback layers. | +| **diagnosing-perf-regressions** | Find why frame rate, frame time, or load time got worse since a known-good state — regression hunting, not general performance tuning. | +| **dispatching-parallel-agents** | Work 2+ independent tasks in parallel when they share no state and have no sequential dependencies. | +| **gameskill** | Capture what a game-dev session just learned as a reusable skill (project, user or Summer library) so the next session starts smarter. | +| **godogen-visual-proof-game-generation** (preview) | Godogen-style game generation with a visual QC loop — capture frames from the running game, self-verify against the brief, bounded fix rounds, proof clip. | +| **headless-scripting** ★ | Run a GDScript file against Summer Engine from the shell for operations no MCP tool exposes — navmesh baking, collision shapes, TileSets, re-imports. | +| **investigating-bugs** ★ | Systematic investigation of any bug, test failure, or unexpected behavior before proposing fixes. | +| **playtesting-a-feature** ★ | Before claiming a gameplay feature done: actually run the game and walk through the feature. Static diagnostics and type checks do not count. | +| **running-in-the-cloud** | Run Summer Engine on a Linux box with no display — install it, launch headless, know when xvfb + software GL are needed, authenticate without a browser. | +| **skill-create** | Bootstrap a new Summer library skill (library/skills// with resource.yaml and SKILL.md), frontmatter, and stub sections. | +| **skill-improve** | Upgrade an underperforming Summer skill — run it against a behavioral spec with and without changes via a parallel-eval harness; ship the winner. | +| **skill-test** | Lint a Summer skill before commit, audit the whole library, or check a behavioral spec assertion — static structural rules plus behavioral specs. | +| **using-summer** | Session bootstrap for Summer projects — establishes how to find and use Summer skills and the summer-engine MCP before any response. | +| **verification-before-completion** ★ | Run verification commands and confirm output before claiming work complete, fixed, or passing — evidence before assertions, always. | +| **writing-plans** | Turn a spec or requirements for a multi-step task into a written implementation plan before touching code. | +| **writing-skills** | Create, edit, and verify agent skills — format, structure, testing with subagents, and best practices. | -### Scripting Patterns +### AI and NPCs | Skill | Use when | |-------|----------| -| **gdscript-patterns** | Writing GDScript: type hints, signals, exports, lifecycle methods | +| **design-npc** ★ | Design enemy/NPC/boss/companion behavior — perception, personality, intent, action state machine, telegraphs — outputs a GDScript stub plus node tree. | -### Character Controllers +### Animation | Skill | Use when | |-------|----------| -| **fps-controller** | Building a first-person CharacterBody3D with movement, camera, and input | +| **animation-tree** | Design and wire AnimationTree state machines and blend trees so clips respond to gameplay — locomotion blends, attack interrupts, hit reactions. | +| **character-animation-wiring** | Wire a rigged, animated character end to end — inspect real clips and bones, locomotion state machine, method-track events, poses, blend shapes, root motion. | +| **facial-and-lipsync** | Make a character's mouth move with a voice-over — phoneme extraction from audio, viseme blendshape mapping, and emotional facial expressions. | +| **generate-motion** ★ | Attach an animation clip to a rigged character from the curated Meshy motion library — idle, walk, run, attack — wired via AnimationPlayer. | +| **procedural-animation** | Runtime bone modification on top of clips — head look-at, foot IK, hand-grabs-prop, additive lean, recoil. Code-and-modifier patterns, not generation. | +| **retarget** | Apply existing animation clips from one rigged character to a different rigged character — same library, multiple models, no regeneration. | -### Gameplay Mechanics +### Asset pipeline | Skill | Use when | |-------|----------| -| **design-mechanic** | Designing a mechanic end to end: input, response, feedback, depth | +| **asset-strategy** ★ | Route any 'I need a [thing]' asset request to the right specialist skill — disambiguates 2D / 3D / audio / video / VFX / animation pipelines. | +| **lumera-single-image-scene-reconstruction** (preview) | Lumera-style single image to editable 3D scene — VLM-parsed object boxes and parametric lights, per-object meshes, HDR probe, .tscn assembly, refinement loop. | +| **skintokens-auto-rigging** (preview) | Offline auto-rigging with skin-tokens.cpp (GGML SkinTokens/TokenRig port) — skeleton and skin weights from a static GLB mesh on CPU/Vulkan, into Godot 4. | -### Level Design +### Audio | Skill | Use when | |-------|----------| -| **design-level** | Designing a level as a paced encounter, then producing a node-tree skeleton | +| **adaptive-music** | Wire music stems to game state — combat/explore/boss/tension crossfades on a shared bus, paired with a state machine and AudioBus structure. | +| **ambient-bed** | Generate a long looping location ambience — forest, dungeon, city, spaceship, cave — a looping AudioStreamPlayer on the Ambient bus with a seamless loop. | +| **audio-direction** ★ | Define the game's sonic identity — music style, instruments, SFX vocabulary, dynamic music plan — output as an audio bible at .summer/audio-bible.md. | +| **music-track** ★ | Generate a looped or cinematic music track — loops authored at >=30s with a marked loop point, cinematic tracks at >=60s linear. | +| **sound-effect** ★ | Generate short SFX one-shots — footsteps, weapon swings, UI clicks, hit impacts — wired as AudioStreamPlayer/2D/3D that auto-frees on finished. | +| **voice-line** ★ | Generate TTS voice lines — NPC barks, narrator, dialogue — with voice-id sourcing, a character-to-voice decision tree, and multi-line dialogue support. | -### Rendering and Lighting +### Character controllers | Skill | Use when | |-------|----------| -| **3d-lighting** | Setting up sun, fill, WorldEnvironment, sky, and shadows | -| **art-direction** | Defining art direction and writing the art bible to `.summer/art-bible.md` | +| **fps-controller** ★ | Production-quality first-person controller — WASD, mouse look, jump, coyote time, jump buffering, air control, and external-velocity handling. | -### UI and UX +### Debugging | Skill | Use when | |-------|----------| -| **ui-basics** | Building menus, HUDs, health bars, and responsive layout | +| **debug** ★ | Disciplined bug/crash/error loop for Summer projects — script errors, console, debugger, hypothesis, fix, verify — before making code or scene changes. | -### Asset Pipeline +### Deployment | Skill | Use when | |-------|----------| -| **asset-strategy** | Choosing between library, generated, or primitive assets for a level | +| **export-and-ship** ★ | Assess and prepare a game export: inventory installed templates and targets, validate release assets and config, produce supported builds after approval. | +| **remote-deploy** ★ | Run or test the game on a real device — phone, tablet, another computer — via the Remote Deploy button, runnable export presets, and on-device debugging. | -### 2D Assets +### Editor | Skill | Use when | |-------|----------| -| **concept-art** | Producing variant concept-art prompts on a locked style anchor | -| **character-portrait** | A final character bust for dialogue UI | -| **pixel-art** | Pixel-art icons and sprites with nearest-neighbor filtering | -| **ui-graphics** | Flat-design UI icon sets and atlases | -| **tileable-texture** | Seamless textures for materials | -| **sprite-sheet** | Multi-frame sprite animations and SpriteFrames resources | -| **skybox-panorama** | Equirectangular skybox panoramas | +| **driving-the-editor-ui** (preview) | Drive the editor UI by name: invoke actions, clear blocking dialogs, switch the main screen, read a dock — and route scene work to the scene tools instead. | -### 3D Assets +### Gameplay | Skill | Use when | |-------|----------| -| **prop-model** | A single prop via the image-to-3D pipeline | -| **character-model** | A character: T-pose reference, gated rig pass, CharacterBody3D wiring | -| **environment-kit** | A modular kit of consistent environment pieces | -| **vehicle-model** | Hard-surface vehicles | -| **organic-model** | Organic shapes with emission and instancing | +| **auto-fire-targeting** | Design or fix auto-fire weapon targeting (survivors, top-down ARPG, tower defense) — the pending-damage pattern that prevents over-commit and overkill. | +| **celeste-momentum-platforming** (preview) | Celeste-style 2D precision platformer movement — momentum running, coyote time, variable jumps, dash, wall jump/slide, climb stamina, pixel corner correction. | +| **design-mechanic** ★ | Design one game mechanic in detail — input, response, feedback, failure modes, depth, tunables — outputs a design doc, node-graph sketch, GDScript stub. | -### Animation +### Level design | Skill | Use when | |-------|----------| -| **generate-motion** | Adding a curated mocap clip to a rigged character | -| **retarget** | Retargeting an existing clip onto a different skeleton | -| **animation-tree** | Building an AnimationTree with blend spaces driven by speed | -| **procedural-animation** | Foot IK and other procedural skeleton modifications | -| **facial-and-lipsync** | Lip-sync and blend-shape facial animation from a voice line | +| **design-level** ★ | Design a single level — layout, pacing, encounters, secrets, reward gating — outputs a level design doc and a node-tree skeleton for summer_create_scene. | +| **scene-to-level** | Go from a scene reference image or concept art to a playable scene — orchestrates concept, asset pack, terrain, composition, and scene assembly. | -### Audio +### Multiplayer | Skill | Use when | |-------|----------| -| **audio-direction** | Defining audio direction and the bus layout in `.summer/audio-bible.md` | -| **sound-effect** | A single SFX wired to an AudioStreamPlayer3D | -| **music-track** | A looping music track on the Music bus | -| **ambient-bed** | Loop-clean ambience on the Ambient bus | -| **voice-line** | Character dialogue via TTS with a matching voice | -| **adaptive-music** | Layered music that responds to combat state | +| **host-authoritative-state** ★ | Design the state layer of a multiplayer game — what the host owns, how clients request changes, and how the host validates and broadcasts. | +| **peer-to-peer-multiplayer** ★ | Start a multiplayer game from scratch with peer-to-peer host authority — network architecture built top-down, before writing game logic. | +| **setup-multiplayer** ★ | Add multiplayer to an existing game — LAN/online co-op, PvP, lobbies — via MultiplayerAPI, MultiplayerSpawner, and MultiplayerSynchronizer. | -### Video +### Navigation | Skill | Use when | |-------|----------| -| **cinematic-cutscene** | A short cutscene wired to a VideoStreamPlayer | -| **trailer-shot** | A premium hero shot for a trailer | -| **animated-loop** | A loop-clean backdrop clip for a title screen | +| **navigate-summer** ★ | When to open a Summer web page or editor surface FOR the user (billing, their games, the scene just built) versus acting through the API, using summer_open. | -### Visual Effects +### Performance | Skill | Use when | |-------|----------| -| **game-feel** | Adding visible juice to flat combat: hit flash, screen shake, particles | -| **fire** | A torch flame via GPUParticles3D and a custom shader | -| **muzzle-flash** | A one-shot muzzle flash on a weapon | -| **water-ripple** | Interactive water ripples | -| **lightning** | A lightning strike effect with camera shake | -| **dissolve** | A dissolve-on-death shader effect | -| **smoke** | Smoke particles with wind | -| **hit-spark** | Sparks oriented to a surface normal on impact | -| **magic-glow** | A pulsing magical glow with light and motes | +| **tune-performance** ★ | Profile a slow game via summer_get_diagnostics, identify rendering/physics/scripting hotspots, propose fixes with before/after metric expectations. | -### AI and NPCs +### Rendering and lighting | Skill | Use when | |-------|----------| -| **design-npc** | A patrol-and-chase enemy with perception, decision logic, and tells | +| **3d-lighting** ★ | Set up 3D scene lighting — DirectionalLight3D vs Omni vs Spot, WorldEnvironment, sky, shadow tuning, ambient — per current Summer conventions. | +| **art-direction** ★ | Define the game's visual style — references, palette, mood, lighting plan, post-processing, do/don't list — output as an art bible at .summer/art-bible.md. | +| **psx-retro-rendering** (preview) | Hardware-informed PlayStation 1 rendering in Godot 4 — low-res output, RGB5 and exact dither, affine textures, vertex snapping, blend modes, fog; limits named. | +| **realtime-wet-surfaces** (preview) | Real-time wetness on existing Godot 4 materials without losing their values — value-copying wet shader, geometry-driven wet mask, instance-uniform wet amount. | -### Multiplayer and Networking +### Runtime | Skill | Use when | |-------|----------| -| **setup-multiplayer** | Co-op LAN multiplayer with MultiplayerAPI, Spawner, Synchronizer, and ENet | -| **peer-to-peer-multiplayer** | A four-layer P2P architecture with prediction and interpolation | -| **host-authoritative-state** | A state-ownership audit and the canonical Manager pattern | +| **agent-playtesting** ★ (preview) | Playtest by driving the LIVE game — deterministic launch, frame-stamped probes before/after each action, exact frame steps, scripted or recorded input. | -### Performance +### Scenes and project | Skill | Use when | |-------|----------| -| **tune-performance** | Profiling a slow scene, finding the hotspot, and verifying the fix moved the metric | +| **brainstorm-game** ★ | Turn a vague idea into a buildable plan — genre, scope, core loop, mechanics, art direction — written as a 1-page brief to .summer/GameSoul.md. | +| **browse-templates** ★ | List available Summer Engine project templates, present the choices, and create a project from the chosen one via summer create. | +| **make-game** ★ | Orchestration spine for 'make me a game': brainstorm, plan, scaffold, mechanics, art, audio, polish, verify, ship — delegates to specialist skills. | +| **new-project** ★ | Create a fresh blank Summer Engine project — asks one question (project name) and runs summer create empty. | +| **play** ★ | Run the project in Summer Engine, wait briefly, then report what's happening — clean run, errors, or warnings. | +| **scene-composition** ★ | Scene structure conventions — node hierarchy, when to extract sub-scenes, reusable prefab patterns, and instance-versus-add-node decisions. | +| **scene-hierarchy-design** (preview) | Structure Summer Engine scenes by access pattern — asset vs live hierarchies, wrapper nodes per operation, sub-scenes for reuse, path-agnostic logic. | +| **scene-scripting** ★ (preview) | One GDScript in the live editor (summer_run_script) builds scenes, 2D levels, HUDs and gameplay wiring instead of CRUD chains; verify with diff + screenshot. | +| **spatial-placement** ★ (preview) | Place and verify 3D objects with Starcast evidence — inspect, place, starcast, correct, verify; floor, shelf, wall, alcove recipes and overlap repair. | +| **verifying-scenes** ★ (preview) | Prove scene work landed — snapshot before, diff + screenshot after (bookmarked viewpoint, labels), live runtime reads during playtests — then claim. | +| **world-building-3d** ★ (preview) | Compose, ground, space, and validate 3D scenes with Summer's four bounded spatial tools — exact paths, one geometric decision at a time, verified. | + +### Scripting -### Debugging +| Skill | Use when | +|-------|----------| +| **gdscript-patterns** ★ | GDScript conventions — type hints, signals, exports, onready, lifecycle methods, get_node vs $NodePath, naming. | + +### UI | Skill | Use when | |-------|----------| -| **debug** | Triaging a runtime crash end to end: read errors, locate code, fix, verify | +| **ui-basics** ★ | Build Summer Engine UI — HUDs, menus, health bars, dialogue boxes, Control trees — anchors, containers, responsive layout, theme vs inline styling. | -### Deployment +### Visual effects + +| Skill | Use when | +|-------|----------| +| **game-feel** ★ | Add juice: hit-flash, trauma-based camera shake, and audio ducking wired so one hit fires all three — for games that feel flat or lack impact. | +| **vfx-dissolve** | Dissolve effect — a mesh disintegrating with a glowing burning edge, driven by a noise-threshold ShaderMaterial overriding the target's material. | +| **vfx-fire** ★ | Fire effect — animated flames built with a particle shader, GPUParticles3D, and a noise-based color ramp — torches, campfires, candles. | +| **vfx-hit-spark** | Hit-spark effect — a one-shot burst of additive billboard particles oriented to a surface normal, fired on impact. | +| **vfx-lightning** | Lightning bolt effect — procedural jagged path drawn via ImmediateMesh, glow shader, sparks at endpoints, screen shake. | +| **vfx-magic-glow** | Magic-glow effect — a pulsing OmniLight3D plus drifting additive motes plus optional emission shader on the source mesh. | +| **vfx-muzzle-flash** ★ | Muzzle-flash effect — a one-shot ~80 ms burst at a gun barrel built with a particle one-shot or a flashing quad with a star-burst shader. | +| **vfx-smoke** | Smoke effect — a slow-rising column or puff of soft particles built with a noise + density falloff shader on a quad mesh, GPUParticles3D. | +| **vfx-water-ripple** | Water-ripple effect — animated normal-distortion ripples on a water plane (or as a Decal) triggered by impacts. | + +### Video | Skill | Use when | |-------|----------| -| **export-and-ship** | Running the Steam pre-flight checklist across Windows, Mac, and Linux | +| **animated-loop** | Generate a short seamlessly-looping video clip — splash background, animated logo backdrop, idle title-screen footage — wired as a looping VideoStreamPlayer. | +| **cinematic-cutscene** ★ | Generate a non-interactive cutscene — reference-locked look, a 5-10s image-to-video shot, optional TTS dialogue — wired as a fading VideoStreamPlayer. | +| **trailer-shot** | Generate marketing or trailer footage — slow-mo combat, establishing shots, hero beats, splash screens, pitch-deck B-roll — max punch in 5-10 seconds. | ## For AI Agents -Most agents discover skills automatically once `summer setup --yes` has installed them. The agent loads the relevant `SKILL.md` when the situation matches, then follows its scene structure, value formats, and tool calls. Skills reference the [MCP tools](/mcp/tools-reference) (`summer_add_node`, `summer_set_prop`, `summer_generate_3d`, etc.) and engine value formats (`Vector3(0, 10, 0)`, `Color(1, 0.5, 0, 1)`). +Once installed, the agent discovers skills on its own. Start a session by reading `using-summer` (the bootstrap skill): it explains how to find the right skill and the right `summer_*` MCP tool before answering a game-development request. Skills reference the [MCP tools](/mcp/tools-reference) and engine value formats (`Vector3(0, 10, 0)`, `Color(1, 0.5, 0, 1)`). + +## Contributing a Skill + +A skill is one folder in `library/skills//` with a `resource.yaml` (id, summary, `use_when`, `facets.domains`) and a `SKILL.md`. Run `npm run generate:registry` and the tests; the index, the agent manifests and this catalog's source regenerate from it. The `writing-skills` skill in the library walks an agent through it. ## Next Steps - + + + Config file and skills folder for each agent + --yes` has > All CLI commands including skills - - Step-by-step MCP workflow for AI agents - --- diff --git a/mcp/vscode.mdx b/mcp/vscode.mdx index df9f7eb..290667d 100644 --- a/mcp/vscode.mdx +++ b/mcp/vscode.mdx @@ -12,6 +12,10 @@ VS Code and GitHub Copilot's coding agent support MCP (Model Context Protocol). This guide covers both **VS Code** (with Copilot or other AI extensions) and **GitHub Copilot's agent mode**—they use the same MCP configuration. + +**Fastest path.** `npx -y summer-engine@latest setup vscode-copilot --yes` writes the config below into `VS Code's user mcp.json`, installs the skill library to `~/.agents/skills`, and runs `summer doctor`. The steps that follow are the manual version of the same thing. + + ## Prerequisites - **VS Code**: With GitHub Copilot (agent mode) or another MCP-aware AI extension @@ -39,7 +43,7 @@ Create `.vscode/mcp.json` in your project root, or open the user config via **MC "summer-engine": { "type": "stdio", "command": "npx", - "args": ["summer-engine", "mcp"] + "args": ["-y", "summer-engine@latest", "mcp"] } } } @@ -52,7 +56,7 @@ Create `.vscode/mcp.json` in your project root, or open the user config via **MC "summer-engine": { "type": "stdio", "command": "npx", - "args": ["summer-engine", "mcp"] + "args": ["-y", "summer-engine@latest", "mcp"] } } } diff --git a/mcp/zed.mdx b/mcp/zed.mdx index 66b53ca..223ff27 100644 --- a/mcp/zed.mdx +++ b/mcp/zed.mdx @@ -12,6 +12,10 @@ Zed is a fast, AI-powered code editor that supports MCP (Model Context Protocol) This guide covers the configuration. Setup takes about a minute. + +**Fastest path.** `npx -y summer-engine@latest setup zed --yes` writes the config below into `~/.config/zed/settings.json`, installs the skill library to `~/.agents/skills`, and runs `summer doctor`. The steps that follow are the manual version of the same thing. + + ## Prerequisites - **Zed**: The high-performance editor with built-in AI @@ -41,7 +45,7 @@ Add the `context_servers` entry. If it already exists, add `summer-engine` to th "context_servers": { "summer-engine": { "command": "npx", - "args": ["summer-engine", "mcp"], + "args": ["-y", "summer-engine@latest", "mcp"], "env": {} } } @@ -54,7 +58,7 @@ Add the `context_servers` entry. If it already exists, add `summer-engine` to th "other-server": { ... }, "summer-engine": { "command": "npx", - "args": ["summer-engine", "mcp"], + "args": ["-y", "summer-engine@latest", "mcp"], "env": {} } } diff --git a/scripts/docs-routes.snapshot.json b/scripts/docs-routes.snapshot.json index 9b644d4..434c862 100644 --- a/scripts/docs-routes.snapshot.json +++ b/scripts/docs-routes.snapshot.json @@ -45,6 +45,7 @@ "desktop/troubleshooting", "mcp/overview", "mcp/setup", + "mcp/agents", "mcp/cursor", "mcp/claude-code", "mcp/devin-desktop",