Summer

https://github.com/summerengine/docs
Admin
Summer is an AI Game Engine that provides tools and resources for game development.
Tokens:9,240
Snippets:78
Trust Score:3.2
Update:1 year ago
Show doc for...
Tokens:
Raw
### Project Setup Guide (Markdown)

Source: https://github.com/summerengine/docs/blob/main/guides/working-with-documentation.mdx

This markdown snippet outlines the necessary steps and prerequisites for setting up a development environment for a project using Godot. It includes version requirements, tooling recommendations, and basic project configuration steps.

```markdown
# Development Environment Setup

## Prerequisites
- Godot 4.5 or later
- Git for version control
- Recommended: VS Code with Godot extensions

## Project Setup
1. Clone the repository: `git clone [repo-url]`
2. Open `project.godot` in Godot Engine
3. Configure project settings in Project → Project Settings
4. Run the main scene to verify setup

## Common Issues
- If assets don't load: Reimport all assets via Project → Reimport Assets
- If scripts show errors: Ensure Godot version matches requirements
```

--------------------------------

### Documentation Attribution Example

Source: https://github.com/summerengine/docs/blob/main/art-system/licensing.mdx

Demonstrates how to document the use of Summer Engine assets in project documentation, specifying creators and licenses.

```text
Third-Party Assets Used:
- Character sprites from Summer user "PixelMaster"
- UI elements by "GameArtist" under Attribution License
```

--------------------------------

### Using Code Examples for Feature Development

Source: https://github.com/summerengine/docs/blob/main/guides/working-with-context.mdx

Shows how to guide feature development by referencing existing, working code. This provides the AI with examples of desired functionality, style, and data structures to replicate or adapt.

```text
Create a new weapon system similar to @sword.gd but for a bow
The bow should have charging mechanics like @magic_staff.gd
Use the same damage calculation system as other weapons in @weapons/
```

--------------------------------

### README File Attribution Example

Source: https://github.com/summerengine/docs/blob/main/art-system/licensing.mdx

Provides a markdown example for including asset attribution in a project's README file, specifying creator and license type.

```markdown
## Assets
This game uses assets from the Summer Art Gallery:
- Background music by MusicCreator (Attribution License)
- Sound effects by AudioPro (Free License)
```

--------------------------------

### Summer Development Setup and Execution

Source: https://github.com/summerengine/docs/blob/main/development/architecture.mdx

Provides bash commands for setting up and running the Summer Engine project. Includes cloning the repository, installing dependencies, building a debug version, and running the application. Also includes commands for plugin development and hot reloading.

```bash
# Clone the repository
git clone https://github.com/SummerEngine/Summer.git
cd Summer

# Install dependencies
./scripts/setup.sh

# Build debug version
scons platform=linux target=editor dev=yes

# Run Summer
./bin/summer.linux.editor.dev.x86_64

```

```bash
# Create new plugin
./scripts/create_plugin.sh my_plugin

# Install for development
ln -s $(pwd)/plugins/my_plugin ~/.summer/plugins/

# Hot reload during development
./bin/summer --dev-plugins

```

--------------------------------

### Start Local Development Server (Mintlify)

Source: https://github.com/summerengine/docs/blob/main/README.md

Starts a local development server for previewing documentation changes. Requires the Mintlify CLI and a docs.json file at the root.

```shell
mint dev
```

--------------------------------

### Project README Structure Example

Source: https://github.com/summerengine/docs/blob/main/guides/working-with-documentation.mdx

Provides an example of a project's README file structure, outlining core systems and development conventions. This helps Summer understand the project's organization, dependencies, and architectural patterns.

```markdown
# Game Project Structure

## Core Systems
- `systems/combat/` - All combat-related logic
- `systems/inventory/` - Item management and storage
- `systems/progression/` - Player leveling and skills

## Conventions
- All managers are singletons following the pattern in `base/singleton_manager.gd`
- UI components inherit from `ui/base_ui_component.gd`
- Game events use the centralized event bus in `core/event_bus.gd`
```

--------------------------------

### Install Mintlify CLI (npm)

Source: https://github.com/summerengine/docs/blob/main/README.md

Installs the Mintlify CLI globally using npm. This tool is used for previewing documentation changes locally.

```shell
npm i -g mint
```

--------------------------------

### In-Game Credits for Attribution

Source: https://github.com/summerengine/docs/blob/main/art-system/licensing.mdx

Example of how to display attribution for assets used in a game's credits section, following the Attribution License requirements.

```text
Art Assets:
- "Fantasy Sword Sprite" by ArtistName (Summer Art Gallery)
- "Stone Texture Pack" by CreatorName (Summer Art Gallery)
```

--------------------------------

### AI Chat - Creating Scripts

Source: https://github.com/summerengine/docs/blob/main/essentials/first-chat.mdx

Example of a user request to create a new script with specific functionality and the AI's planned response.

```text
You: Add a health system to the player that starts at 100
Summer: I'll create a health.gd script with health = 100 and damage/heal functions.
```

--------------------------------

### AI Chat - Adding Objects

Source: https://github.com/summerengine/docs/blob/main/essentials/first-chat.mdx

Example of a user request to add a red cube to the scene and the AI's planned response.

```text
You: Add a red cube to the center of the scene
Summer: I'll create a MeshInstance3D with a BoxMesh and red material at position (0,0,0).
```

--------------------------------

### Search for Godot Documentation

Source: https://github.com/summerengine/docs/blob/main/guides/working-with-documentation.mdx

Demonstrates how to prompt Summer to search for specific Godot engine documentation, focusing on version-specific information and implementation examples. This is useful for finding current best practices and API details.

```natural language
Search for the latest Godot 4.5 documentation on AnimationPlayer
Find examples of implementing state machines in Godot
Look up best practices for multiplayer networking in Godot 4
```

--------------------------------

### Install Missing Dependencies (Ubuntu)

Source: https://github.com/summerengine/docs/blob/main/desktop/troubleshooting.mdx

Installs required packages on Ubuntu for Summer engine, specifically addressing missing dependencies that may cause errors. This command assumes apt package manager is used.

```bash
sudo apt install libgl1-mesa-dev
```

--------------------------------

### Static Hosting Deployment Configuration

Source: https://github.com/summerengine/docs/blob/main/guides/web-development.mdx

Details configurations for deploying to static hosting services, such as GitHub Pages, Netlify, and AWS S3, including build configurations and custom domain setup.

```plaintext
Configure builds for GitHub Pages deployment
Set up automated deployment to Netlify
Create build scripts for AWS S3 hosting
Add custom domain configuration
```

--------------------------------

### Component-Based Architecture Example (Text)

Source: https://github.com/summerengine/docs/blob/main/guides/large-codebases.mdx

This text provides an example of how to create a new HealthComponent following established patterns within a component-based architecture.

```text
Create a new HealthComponent following the pattern in @components/
- Inherits from BaseComponent like @components/movement_component.gd
- Provides health, max_health, and damage/heal methods
- Emits health_changed and death signals
- Can be attached to any entity that needs health
```

--------------------------------

### Isolation Testing Setup (Text)

Source: https://github.com/summerengine/docs/blob/main/guides/large-codebases.mdx

This text describes how to set up a simple test scene to isolate specific systems for debugging, ensuring only relevant components are loaded.

```text
Create a simple test scene that only loads:
- @systems/inventory_manager.gd
- @data/item_database.gd
- Basic test items

This will help us isolate the inventory bug from other systems
```

--------------------------------

### Documentation Generation Command (Text)

Source: https://github.com/summerengine/docs/blob/main/guides/large-codebases.mdx

This text describes a command to generate documentation for a specific folder, including class descriptions, method signatures, and usage examples, formatted as markdown.

```text
Generate documentation for the @systems/combat/ folder
Include class descriptions, public method signatures, and usage examples
Format as markdown for our project wiki
```

--------------------------------

### GDScript Plugin Example

Source: https://github.com/summerengine/docs/blob/main/development/architecture.mdx

Demonstrates the basic structure for creating a Summer Engine plugin using GDScript. It shows how to extend the SummerPlugin class, register custom commands, and add menu items for user interaction.

```gdscript
# Example plugin structure
extends SummerPlugin

func _ready():
    register_command("my_command", handle_command)
    add_menu_item("Tools/My Plugin", show_dialog)

func handle_command(args: Dictionary):
    # Custom AI command logic
    pass

```

--------------------------------

### System Boundaries Example (Text)

Source: https://github.com/summerengine/docs/blob/main/guides/large-codebases.mdx

This text defines clear boundaries for an inventory system, specifying its responsibilities and what it should not do, to ensure system decoupling.

```text
The inventory system should only:
- Manage item storage and retrieval
- Handle item stacking and splitting
- Emit inventory_changed signals

It should NOT:
- Update UI directly (that's the UI system's job)
- Handle item usage effects (that's the item system's job)
- Manage player stats (that's the stats system's job)
```

--------------------------------

### AI Art Prompt Examples for Game Development

Source: https://github.com/summerengine/docs/blob/main/art-system/ai-generation.mdx

Examples of prompts for generating different types of game assets using AI, including character sprites, environment textures, UI elements, and concept art. These demonstrate structure and detail for effective AI image generation.

```plaintext
A brave knight in silver armor, cartoon style, bright cheerful lighting, facing forward for game sprite
```

```plaintext
Seamless stone brick texture, medieval fantasy style, weathered and moss-covered, tileable pattern
```

```plaintext
Wooden game button with gold trim, fantasy RPG style, glowing hover effect, ornate carved details
```

```plaintext
Mystical forest clearing, anime style, soft magical lighting, ancient ruins in background
```

--------------------------------

### Automated Testing for Web Deployment

Source: https://github.com/summerengine/docs/blob/main/guides/web-development.mdx

Describes the setup of comprehensive automated testing for web deployment, including unit tests for web-specific functionality, integration tests for browser API usage, visual regression tests, and performance benchmarking.

```plaintext
Create unit tests for web-specific functionality
Add integration tests for browser API usage
Implement visual regression testing for UI changes
Set up performance benchmarking for web builds
```

--------------------------------

### AI Chat - Setting Properties

Source: https://github.com/summerengine/docs/blob/main/essentials/first-chat.mdx

Example of a user request to modify an object's property (player speed) and the AI's planned response.

```text
You: Make the player move twice as fast
Summer: I'll find your player script and increase the speed variable from 5.0 to 10.0.
```

--------------------------------

### AI Art Prompt Enhancement Example

Source: https://github.com/summerengine/docs/blob/main/art-system/ai-generation.mdx

Demonstrates the difference between a basic prompt and an AI-enhanced prompt for art generation. The enhanced prompt provides more detail and context, leading to a potentially better output.

```plaintext
Original: "A sword"
Enhanced: "A gleaming medieval longsword with ornate crossguard, leather-wrapped grip, and polished steel blade reflecting light, fantasy RPG style"
```

--------------------------------

### API Documentation for Inventory Management (GDScript)

Source: https://github.com/summerengine/docs/blob/main/guides/working-with-documentation.mdx

This GDScript code provides API documentation for an InventoryManager class. It details the purpose of the class, its capabilities like item stacking and weight limits, and includes an example of its usage.

```gdscript
## Inventory management system for handling player items
##
## Provides methods for adding, removing, and querying items in the player's
## inventory. Supports item stacking, weight limits, and category filtering.
##
## Example usage:
## [codeblock]
          ## var inventory = InventoryManager.get_instance()
## inventory.add_item("health_potion", 5)
## var potion_count = inventory.get_item_count("health_potion")
## [/codeblock]
class_name InventoryManager extends Node
```

--------------------------------

### Debugging Context with Crash Reports

Source: https://github.com/summerengine/docs/blob/main/guides/working-with-context.mdx

Provides an example of how to structure context when reporting a crash. It includes the error message, the location of the crash, and references to relevant script files for the AI to analyze.

```text
I'm getting a crash when the player dies. Here's the error: [paste error]
The crash happens in @game_manager.gd at line 45
The player death is handled in @player.gd around line 120
```

--------------------------------

### Sharing Public Collection URL Example

Source: https://github.com/summerengine/docs/blob/main/art-system/collections.mdx

This snippet shows the format of a shareable URL for a public asset collection on the Summerengine platform. It includes placeholders for the username and collection name.

```text
summerengine.com/art/collections/username/collection-name
```

--------------------------------

### Get Chat History

Source: https://github.com/summerengine/docs/blob/main/api-reference/chat-api.mdx

Retrieve previous chat interactions for a project.

```APIDOC
## GET /v1/projects/{project_id}/chat

### Description
Retrieve previous chat interactions for a project.

### Method
GET

### Endpoint
/v1/projects/{project_id}/chat

### Parameters
#### Path Parameters
- **project_id** (string) - Required - The ID of the project to retrieve history for

#### Query Parameters
- **limit** (integer) - Optional - Defaults to 50. Maximum number of chat messages to return (1-100)
- **offset** (integer) - Optional - Defaults to 0. Number of messages to skip for pagination

### Response
#### Success Response (200)
- **chats** (array) - List of chat interactions
  - **id** (string) - Unique identifier for the chat interaction
  - **message** (string) - The original message sent
  - **response** (string) - Summer's explanation of what it will do
  - **applied** (boolean) - Whether the changes were actually applied to the project
  - **created_at** (string) - Timestamp of when the chat interaction was created
- **total** (integer) - Total number of chat messages available
- **has_more** (boolean) - Indicates if there are more messages available beyond the current response

#### Response Example
```json
{
  "chats": [
    {
      "id": "chat_abc123",
      "message": "Add a red cube to the scene",
      "response": "I'll create a MeshInstance3D...",
      "applied": true,
      "created_at": "2024-01-15T10:30:00Z"
    }
  ],
  "total": 25,
  "has_more": false
}
```
```

--------------------------------

### Iterative Code Exploration and Modification

Source: https://github.com/summerengine/docs/blob/main/guides/large-codebases.mdx

A step-by-step approach to understanding and modifying code, starting with high-level questions and progressively narrowing down to specific implementation details and focused changes.

```natural-language
How is the inventory system organized in this project?
```

```natural-language
Looking at @inventory/inventory_manager.gd, how does item stacking work?
```

```natural-language
In @inventory/item.gd, modify the stack_size property to support different stack limits per item type
```

--------------------------------

### Retrieve Chat History using cURL and JavaScript

Source: https://github.com/summerengine/docs/blob/main/api-reference/chat-api.mdx

Retrieve previous chat interactions for a specific project. This involves making a GET request to the /v1/projects/{project_id}/chat endpoint. It supports cURL and JavaScript, with optional query parameters for pagination.

```bash
curl -X GET "https://api.summerengine.com/v1/projects/proj_abc123/chat" \
  -H "Authorization: Bearer sk-summer-..."
```

```javascript
const response = await fetch(
  'https://api.summerengine.com/v1/projects/proj_abc123/chat',
  {
    headers: {
      'Authorization': 'Bearer sk-summer-...' 
    }
  }
);

const history = await response.json();
```

--------------------------------

### Reference Godot API Documentation

Source: https://github.com/summerengine/docs/blob/main/guides/working-with-documentation.mdx

Shows how to instruct Summer to follow specific documentation for game development tasks, such as implementing player controllers or using particular methods. This ensures adherence to official patterns and best practices.

```natural language
Following the Godot documentation for CharacterBody2D, 
implement a player controller with proper collision detection
Use the move_and_slide() method as described in the official docs
```

--------------------------------

### Plant Store API Endpoints

Source: https://github.com/summerengine/docs/blob/main/api-reference/introduction.mdx

Documentation for the Plant Store API, covering authentication and various endpoints.

```APIDOC
## Plant Store API Endpoints

### Description
This API allows users to interact with the Plant Store, providing access to plant information, orders, and more. All endpoints require Bearer token authentication.

### Method
GET, POST, PUT, DELETE (Specific methods depend on the endpoint)

### Endpoint
/api/plants, /api/orders, etc. (Refer to the OpenAPI specification for exact endpoints)

### Authentication
All API endpoints are authenticated using Bearer tokens.

```json
{
  "security": [
    {
      "bearerAuth": []
    }
  ]
}
```

### Request Example
```json
{
  "Authorization": "Bearer YOUR_API_TOKEN"
}
```

### Response
#### Success Response (200)
- **data** (object) - The response data containing requested information.

#### Response Example
```json
{
  "data": {
    "message": "Successfully retrieved plant information"
  }
}
```
```

--------------------------------

### Apply Godot Documentation Patterns

Source: https://github.com/summerengine/docs/blob/main/guides/working-with-documentation.mdx

Illustrates how to prompt Summer to create or implement code elements based on documented patterns and conventions within the Godot engine. This ensures consistency and leverages established development practices.

```natural language
Create a custom Resource class following Godot's documentation patterns
Implement the _get_property_list() method as shown in the Godot docs
Use @export annotations according to Godot 4 best practices
```

--------------------------------

### Combat System Architecture Documentation

Source: https://github.com/summerengine/docs/blob/main/guides/working-with-documentation.mdx

Outlines the high-level architecture of a combat system using a component-based approach. It details core components, their responsibilities, and the event flow, providing Summer with a clear understanding of the system's design.

```markdown
# Combat System Architecture

## Overview
The combat system is built around a component-based architecture where entities can have multiple combat-related components.

## Core Components
- `HealthComponent`: Manages health, damage, and death
- `AttackComponent`: Handles damage dealing and attack timing
- `DefenseComponent`: Manages armor, resistances, and damage reduction

## Event Flow
1. Attack initiated → AttackComponent processes
2. Damage calculated → sent to target's HealthComponent
3. Health changed → UI updated via signals
4. Death triggered → cleanup and rewards processed
```

--------------------------------

### Generate Documentation from Code

Source: https://github.com/summerengine/docs/blob/main/guides/working-with-documentation.mdx

Provides instructions for analyzing a specific system within a project and generating documentation that covers its functionality, API, integration points, and usage patterns. This is part of a documentation-driven development workflow.

```natural language
Analyze @systems/inventory/ and create documentation covering:
- How the inventory system works
- Public API methods and their parameters
- Integration points with other systems
- Common usage patterns and examples
```

--------------------------------

### Linking Code to Architecture Documentation (GDScript)

Source: https://github.com/summerengine/docs/blob/main/guides/working-with-documentation.mdx

This GDScript snippet demonstrates how to link code implementation to external architectural documentation using comments. It specifies the pattern being implemented and provides a reference to the relevant documentation file.

```gdscript
## Implements the observer pattern as described in our architecture docs
## See: docs/patterns/observer-pattern.md for usage guidelines
class_name EventBus extends Node

## Subscribes a callback to an event type
## @param event_type: String identifier for the event
## @param callback: Callable to invoke when event fires
## @param subscriber: Object that owns the callback (for cleanup)
func subscribe(event_type: String, callback: Callable, subscriber: Object):
    # Implementation follows the pattern documented in observer-pattern.md
```

--------------------------------

### Singleton Pattern Documentation (Markdown)

Source: https://github.com/summerengine/docs/blob/main/guides/large-codebases.mdx

This markdown snippet outlines the documentation for a Singleton Manager Pattern, specifying conventions for manager classes, exports, initialization, and communication.

```markdown
---
description: Singleton Manager Pattern
globs: "**/managers/*.gd"
---

1. All manager classes extend from BaseManager
2. Use @export var for configuration in editor
3. Initialize in _ready(), cleanup in _exit_tree()
4. Provide static get_instance() method
5. Emit signals for state changes, don't call other systems directly
```

--------------------------------

### GDScript Inline Code Documentation

Source: https://github.com/summerengine/docs/blob/main/guides/working-with-documentation.mdx

Demonstrates comprehensive inline documentation within a GDScript class, explaining its purpose, dependencies, and key properties. This allows Summer to understand the functionality and context of the code.

```gdscript
## Player controller handling movement, jumping, and basic interactions
## 
## This class manages all player input and translates it into game actions.
## It follows the standard CharacterBody2D pattern from Godot 4.x documentation.
##
## Dependencies:
## - InputManager for input handling
## - PlayerStats for movement parameters
## - EventBus for broadcasting player events
class_name PlayerController extends CharacterBody2D

## Movement speed in pixels per second
## Configured in the editor, typical values: 200-400
@export var speed: float = 300.0

## Jump velocity (negative because Y-axis is inverted)
## Higher absolute values = higher jumps
@export var jump_velocity: float = -400.0
```

--------------------------------

### Continuous Deployment Pipeline Automation

Source: https://github.com/summerengine/docs/blob/main/guides/web-development.mdx

Describes automating the deployment pipeline using tools like GitHub Actions, setting up staging environments, implementing blue-green deployment for zero downtime, and adding rollback capabilities.

```plaintext
Set up GitHub Actions for automated builds
Create staging environments for testing
Implement blue-green deployment for zero downtime
Add rollback capabilities for failed deployments
```

--------------------------------

### CDN Integration for Performance Optimization

Source: https://github.com/summerengine/docs/blob/main/guides/web-development.mdx

Explains how to integrate content delivery networks (CDNs) like CloudFlare and AWS CloudFront for global content delivery and asset distribution, including cache header configuration and geographic optimization.

```plaintext
Configure CloudFlare for global content delivery
Set up AWS CloudFront for asset distribution
Implement cache headers for optimal performance
Add geographic content optimization
```

--------------------------------

### Code Review and Optimization Context

Source: https://github.com/summerengine/docs/blob/main/guides/working-with-context.mdx

Shows how to request code reviews and optimizations by specifying the script to analyze, the constraints (e.g., number of instances), and areas of focus within the code, referencing other scripts for comparative analysis.

```text
Review @enemy_ai.gd for performance issues
This script runs for 50+ enemies simultaneously
Focus on the pathfinding in the _process function
Consider the patterns used in @player_controller.gd for optimization ideas
```

--------------------------------

### Web Project Code Organization Structure

Source: https://github.com/summerengine/docs/blob/main/guides/web-development.mdx

Illustrates a recommended directory structure for organizing web-specific GDScript files, assets, HTML templates, CSS stylesheets, and deployment scripts within a web project.

```treeview
web/
├── scripts/           # Web-specific GDScript files
├── assets/           # Web-optimized assets
├── templates/        # HTML templates
├── styles/           # CSS stylesheets
└── deployment/       # Build and deployment scripts
```

--------------------------------

### GdScript Game Manager and Player Spawning

Source: https://github.com/summerengine/docs/blob/main/ai-tools/rag-search.mdx

Shows how Summer interprets project comments to understand the role of singletons and specific functions, like player spawning, within GdScript.

```gdscript
# SUMMER: This is the main game manager singleton
extends Node

# SUMMER: Handle player spawning and respawning
func spawn_player():
    pass

```

--------------------------------

### Update Documentation from Code Changes

Source: https://github.com/summerengine/docs/blob/main/guides/working-with-documentation.mdx

Instructs on how to update existing documentation to reflect recent code refactoring, including changes in file format, method signatures, and integration points with other modules. This ensures documentation remains current with code evolution.

```natural language
I've refactored the save system in @systems/save_manager.gd
Update the documentation in docs/save-system.md to reflect:
- New save file format
- Changed method signatures
- Updated integration with @systems/game_state.gd
```

--------------------------------

### Context for New Feature Implementation

Source: https://github.com/summerengine/docs/blob/main/guides/working-with-context.mdx

Demonstrates how to provide context when requesting new features, including references to existing code for structure and style guidelines for UI elements and data management.

```text
I want to add a dialogue system to my RPG
Look at @npc.gd to see how NPCs are currently structured
The UI should match the style of @ui/menu.gd
Store dialogue data similar to how @quest_data.gd works
```

--------------------------------

### Initialize Summer API Client (JavaScript)

Source: https://github.com/summerengine/docs/blob/main/essentials/authentication.mdx

This JavaScript code snippet demonstrates how to initialize the SummerAPI client using an API key. It assumes the API key is stored in an environment variable `SUMMER_API_KEY` for security.

```javascript
const summer = new SummerAPI({
  apiKey: process.env.SUMMER_API_KEY
});
```

--------------------------------

### User Testing and Feedback Collection

Source: https://github.com/summerengine/docs/blob/main/guides/web-development.mdx

Outlines methods for gathering user feedback for web deployment, including in-game feedback systems, crash reporting, user behavior tracking with privacy considerations, and beta testing programs.

```plaintext
Add in-game feedback collection system
Implement crash reporting for web deployment
Create user behavior tracking (with privacy considerations)
Set up beta testing programs for web users
```

--------------------------------

### Troubleshooting Player Collision Issues (Markdown)

Source: https://github.com/summerengine/docs/blob/main/guides/working-with-documentation.mdx

This markdown section addresses a common troubleshooting issue where a player character falls through the floor. It explains the likely cause related to physics processing timing and provides a solution.

```markdown
# Common Issues and Solutions

## Player Falls Through Floor
**Symptoms**: Player character clips through solid platforms
**Cause**: Collision detection running at wrong physics step
**Solution**: Move collision code from `_process()` to `_physics_process()`
```

--------------------------------

### Team Documentation Standards for Code Comments (Markdown)

Source: https://github.com/summerengine/docs/blob/main/guides/working-with-documentation.mdx

This markdown outlines team standards for code comments, emphasizing the need for doc comments on public methods, explanatory comments for complex logic, and specific formatting for TODO comments.

```markdown
# Team Documentation Standards

## Code Comments
- All public methods must have doc comments
- Complex algorithms need explanatory comments
- TODO comments must include assignee and date
```

--------------------------------

### Detailed Planning with Ask Mode

Source: https://github.com/summerengine/docs/blob/main/guides/large-codebases.mdx

Utilize Summer's Ask mode to generate detailed implementation plans for new features. This involves specifying requirements and allowing the AI to ask clarifying questions.

```natural-language
I need to add a crafting system to this RPG project.

Looking at @inventory/, @items/, and @ui/ folders, create a plan for:
- Where to place crafting-related scripts
- How to integrate with the existing inventory system
- What UI components we'll need
- How to store crafting recipes

Ask me questions if you need clarification about requirements.
```

--------------------------------

### Use Specific File References

Source: https://github.com/summerengine/docs/blob/main/guides/large-codebases.mdx

When discussing code, reference specific files and their roles to provide precise context for the AI.

```text
Looking at @systems/combat/damage_calculator.gd and @entities/player.gd,
I need to add armor penetration mechanics that reduce damage mitigation
```

--------------------------------

### Breaking Down Complex Requests for AI

Source: https://github.com/summerengine/docs/blob/main/guides/working-with-context.mdx

Explains the strategy of dividing large, complex development tasks into smaller, sequential requests. This approach helps the AI manage the scope and deliver incremental progress effectively.

```text
First, let's create a basic inventory data structure that can hold items
Then we'll add the UI for displaying items
Finally, we'll implement drag-and-drop functionality
```

--------------------------------

### Browser Developer Tools Usage for Debugging

Source: https://github.com/summerengine/docs/blob/main/guides/web-development.mdx

Details how to leverage browser developer tools for web-specific debugging, including console logging, performance profiling, remote debugging for mobile, and creating debug commands.

```plaintext
Add console logging for web-specific debugging
Use browser performance profiler for optimization
Implement remote debugging for mobile browsers
Create debug commands accessible from browser console
```

--------------------------------

### Update Mintlify CLI

Source: https://github.com/summerengine/docs/blob/main/README.md

Updates the Mintlify CLI to the latest version. This is a troubleshooting step to ensure you have the most recent CLI features.

```shell
mint update
```

--------------------------------

### Providing Debugging Context with Error Information

Source: https://github.com/summerengine/docs/blob/main/guides/working-with-context.mdx

Illustrates how to supply context for debugging by including specific error messages and referencing the files and lines where the error occurs. This aids the AI in pinpointing the source of the problem.

```text
I'm getting this error: "Cannot call method 'move_and_slide' on null instance"
The error happens in @player.gd at line 45
Looking at @level.gd, I think the issue might be in how we instantiate the player
```

--------------------------------

### Referencing Files and Functions with '@' Symbol

Source: https://github.com/summerengine/docs/blob/main/guides/working-with-context.mdx

Demonstrates how to use the '@' symbol within Summer's chat to provide context by referencing specific files, folders, or functions. This helps the AI understand which code elements are relevant to the current request.

```text
Using @player.gd as reference, create a similar enemy.gd script with different movement patterns
```

--------------------------------

### Summer Project Ignore File Configuration

Source: https://github.com/summerengine/docs/blob/main/ai-tools/rag-search.mdx

Illustrates the format of a `.summerignore` file used to specify patterns and directories that Summer should not analyze, ensuring efficient project indexing.

```ignore
# Don't analyze generated files
.import/
builds/
temp/

# Skip third-party code
addons/third_party/

```

--------------------------------

### Documenting Project Patterns with Summer Rules

Source: https://github.com/summerengine/docs/blob/main/guides/large-codebases.mdx

Define and enforce project-specific coding conventions and architectural patterns using Summer's Rules system. This markdown format allows clear documentation of established practices.

```markdown
---
description: Combat System Patterns
---

1. All combat entities inherit from CombatEntity base class
2. Damage calculations use DamageCalculator.calculate_damage()
3. Status effects are managed through StatusEffectManager
4. Combat events are broadcast via CombatEventBus
5. Health changes trigger UI updates through HealthDisplay component
```

--------------------------------

### JavaScript Interop in GDScript

Source: https://github.com/summerengine/docs/blob/main/guides/web-development.mdx

This GDScript code demonstrates how to interface with JavaScript for web-specific features, allowing communication between Godot and browser APIs. It includes functions to call JavaScript from GDScript and to signal readiness from Godot to the browser.

```gdscript
## Interface with JavaScript for web-specific features
## Handles communication between Godot and browser APIs
class_name WebInterface extends Node

## Call JavaScript function from GDScript
func call_js_function(function_name: String, args: Array = []):
    if OS.has_feature("web"):
        JavaScriptBridge.eval(function_name + "(" + str(args) + ")")

## Receive data from JavaScript
func _ready():
    if OS.has_feature("web"):
        JavaScriptBridge.eval("window.godot_ready = true")
```

--------------------------------

### GdScript Player Controller Analysis

Source: https://github.com/summerengine/docs/blob/main/ai-tools/rag-search.mdx

Demonstrates how Summer understands a typical player controller script in GdScript, identifying classes, variables, and their purpose within the physics process.

```gdscript
# Summer knows this is a player controller
extends CharacterBody3D
class_name Player

@export var speed: float = 5.0
@export var jump_velocity: float = 4.5

func _physics_process(delta):
    # Summer understands this handles movement
    handle_movement(delta)

```

--------------------------------

### Set API Key Environment Variable (Bash)

Source: https://github.com/summerengine/docs/blob/main/essentials/authentication.mdx

This command sets your Summer API key as an environment variable named SUMMER_API_KEY. This is a common practice for securely managing API keys in terminal-based workflows.

```bash
export SUMMER_API_KEY="your-api-key-here"
```

--------------------------------

### Replicating Functionality Across Codebase

Source: https://github.com/summerengine/docs/blob/main/guides/large-codebases.mdx

Leverage existing code patterns to implement new features. This involves referencing similar implementations and integrating new systems with established ones.

```natural-language
Create a new spell system similar to @abilities/melee_ability.gd
Follow the same pattern as @abilities/ranged_ability.gd for targeting
Use the cooldown system from @systems/cooldown_manager.gd
Integrate with the UI like @ui/ability_bar.gd does for other abilities
```

--------------------------------

### Send Chat Message

Source: https://github.com/summerengine/docs/blob/main/api-reference/chat-api.mdx

Send a natural language request to Summer's AI to interact with your project.

```APIDOC
## POST /v1/chat

### Description
Send a natural language request to Summer's AI.

### Method
POST

### Endpoint
/v1/chat

### Parameters
#### Request Body
- **message** (string) - Required - The natural language request to process
- **project_id** (string) - Required - The ID of the project to operate on
- **apply_changes** (boolean) - Optional - Defaults to false. Whether to automatically apply the changes or just return the plan
- **context** (string) - Optional - Additional context to help the AI understand your request

### Request Example
```json
{
  "message": "Add a red cube to the scene",
  "project_id": "proj_abc123",
  "apply_changes": true
}
```

### Response
#### Success Response (200)
- **id** (string) - Unique identifier for this chat interaction
- **message** (string) - The original message sent
- **response** (string) - Summer's explanation of what it will do
- **changes** (array) - List of specific changes that were made or planned
- **applied** (boolean) - Whether the changes were actually applied to the project
- **created_at** (string) - Timestamp of when the chat interaction was created

#### Response Example
```json
{
  "id": "chat_abc123",
  "message": "Add a red cube to the scene",
  "response": "I'll create a MeshInstance3D with a BoxMesh and red material at the scene root.",
  "changes": [
    {
      "type": "create_node",
      "parent": "Main",
      "node_type": "MeshInstance3D",
      "name": "Cube",
      "properties": {
        "mesh": "BoxMesh",
        "material": "RedMaterial"
      }
    }
  ],
  "applied": true,
  "created_at": "2024-01-15T10:30:00Z"
}
```
```

--------------------------------

### Team Coding Standards (Markdown)

Source: https://github.com/summerengine/docs/blob/main/guides/large-codebases.mdx

This markdown snippet defines team-wide coding standards for consistency, covering naming conventions, documentation, exports, private method prefixes, and file grouping.

```markdown
---
description: Team Coding Standards
---

1. Use PascalCase for class names, snake_case for variables
2. All public methods must have documentation comments
3. Use @export for designer-configurable values
4. Prefix private methods with underscore (_private_method)
5. Group related functionality in the same script file
```

--------------------------------

### Provide Architectural Context

Source: https://github.com/summerengine/docs/blob/main/guides/large-codebases.mdx

When working on a feature or fixing a bug, provide context about the project's architecture and data flow to help the AI understand the system.

```text
I'm working on the player progression system in our RPG.
Architecture: @systems/progression/ contains all progression logic
Data flow: XP gains → @progression_manager.gd → @player_stats.gd → UI updates
Current issue: Level-up rewards aren't being applied correctly
```

--------------------------------

### Exploring Project Architecture with Chat

Source: https://github.com/summerengine/docs/blob/main/guides/large-codebases.mdx

Use natural language queries in chat to understand the high-level architecture and data flow within a project. This helps in grasping system design and key functionalities.

```natural-language
What does the combat system architecture look like in this project?
Show me how player input flows through the codebase
Where is the save/load functionality implemented?
```

```natural-language
Trace how a player action becomes a game state change
Show me the path from @input_handler.gd to @game_state.gd
What happens when a player clicks the attack button?
```

```natural-language
What files depend on @player_manager.gd?
Show me all the systems that use @event_bus.gd
Which scripts are called by @level_loader.gd?
```

--------------------------------

### Strategic Planning for Large Changes

Source: https://github.com/summerengine/docs/blob/main/guides/large-codebases.mdx

Break down complex tasks into smaller, manageable steps for effective implementation. This approach contrasts with broad, overwhelming change requests.

```natural-language
1. First, let's identify all the places where combat state is stored
2. Then we'll extract combat logic into a separate manager class
3. Next, we'll make the combat state serializable for network sync
4. Finally, we'll add network event broadcasting for combat actions
```

--------------------------------

### OpenAPI Security Scheme

Source: https://github.com/summerengine/docs/blob/main/api-reference/introduction.mdx

Demonstrates how to define Bearer token authentication within an OpenAPI specification. This JSON snippet configures the security requirements for API endpoints, expecting a 'bearerAuth' token.

```json
{
  "security": [
    {
      "bearerAuth": []
    }
  ]
}
```

--------------------------------

### Systematic Debugging - Tracing Data Flow (Text)

Source: https://github.com/summerengine/docs/blob/main/guides/large-codebases.mdx

This text outlines a systematic approach to debugging a data saving issue by tracing the data flow through different system components.

```text
I have a bug where player stats aren't saving correctly.

Let's trace the data flow:
1. Check @player/player_stats.gd - are stats being updated correctly?
2. Look at @systems/save_system.gd - is the save data being serialized?
3. Examine @data/save_data.gd - is the data structure correct?
4. Review @systems/file_manager.gd - are files being written to disk?
```

--------------------------------

### Data Flow Architecture Diagram

Source: https://github.com/summerengine/docs/blob/main/PRIVACY_MODE_PRD.md

Illustrates the proposed data flow for user code, emphasizing immediate deletion after response and no persistent storage or training data extraction.

```text
User Code → Summer Client → Summer API → AI Provider → Response → User
                ↓
        Immediate deletion after response
        No persistent storage
        No training data extraction
```

--------------------------------

### Send Chat Message using cURL, JavaScript, and Python

Source: https://github.com/summerengine/docs/blob/main/api-reference/chat-api.mdx

Send a natural language request to Summer's AI. This involves making a POST request to the /v1/chat endpoint with the message, project ID, and optionally whether to apply changes. It supports cURL, JavaScript, and Python.

```bash
curl -X POST "https://api.summerengine.com/v1/chat" \
  -H "Authorization: Bearer sk-summer-..." \
  -H "Content-Type: application/json" \
  -d '{
    "message": "Add a red cube to the scene",
    "project_id": "proj_abc123",
    "apply_changes": true
  }'
```

```javascript
const response = await fetch('https://api.summerengine.com/v1/chat', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer sk-summer-...',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    message: 'Add a red cube to the scene',
    project_id: 'proj_abc123',
    apply_changes: true
  })
});

const result = await response.json();
```

```python
import requests

response = requests.post(
    'https://api.summerengine.com/v1/chat',
    headers={'Authorization': 'Bearer sk-summer-...'}, 
    json={
        'message': 'Add a red cube to the scene',
        'project_id': 'proj_abc123',
        'apply_changes': True
    }
)

result = response.json()
```

--------------------------------

### Summer Engine Privacy Mode Data Flow

Source: https://github.com/summerengine/docs/blob/main/security/privacy-mode.mdx

Illustrates the secure and ephemeral data flow for code processing within Summer Engine, emphasizing zero long-term storage and no training usage.

```mermaid
graph TD
    A[Your Code] --> B(Summer encrypted)
    B --> C{AI Provider}
    C --> D[Response]
    D --> A
    B --> E[Deleted immediately after response]
    E --> F[Never stored long-term]
    E --> G[Never used for training]
    E --> H[Never shared with others]
```
Tokens:
Raw