diff --git a/packages/kilo-docs/docs/advanced-usage/auto-cleanup.md b/packages/kilo-docs/docs/advanced-usage/auto-cleanup.md index c9fb9b89a..6ec7619d7 100644 --- a/packages/kilo-docs/docs/advanced-usage/auto-cleanup.md +++ b/packages/kilo-docs/docs/advanced-usage/auto-cleanup.md @@ -241,7 +241,7 @@ Task data is stored in your VS Code global storage location: ## Related Features - [**Checkpoints**](../features/checkpoints): Version control for tasks that can be restored -- [**Settings Management**](../features/settings-management): Export/import settings including cleanup configuration +- [**Settings Management**](../customization/settings-management): Export/import settings including cleanup configuration - [**Task History**](../basic-usage/the-chat-interface): Managing and organizing your task history ## Frequently Asked Questions diff --git a/packages/kilo-docs/docs/advanced-usage/memory-bank.md b/packages/kilo-docs/docs/advanced-usage/memory-bank.md index 6243fa547..034f965f3 100644 --- a/packages/kilo-docs/docs/advanced-usage/memory-bank.md +++ b/packages/kilo-docs/docs/advanced-usage/memory-bank.md @@ -35,7 +35,7 @@ When Memory Bank is active, Kilo Code begins each task with `[Memory Bank: Activ ## How Memory Bank Works -Memory Bank is built on Kilo Code's [Custom Rules](/advanced-usage/custom-rules) feature, providing a specialized framework for project documentation. Memory Bank files are standard markdown files stored in `.kilocode/rules/memory-bank` folder within your project repository. They're not hidden or proprietary - they're regular documentation files that both you and Kilo Code can access. +Memory Bank is built on Kilo Code's [Custom Rules](/customization/custom-rules) feature, providing a specialized framework for project documentation. Memory Bank files are standard markdown files stored in `.kilocode/rules/memory-bank` folder within your project repository. They're not hidden or proprietary - they're regular documentation files that both you and Kilo Code can access. At the start of every task, Kilo Code reads all Memory Bank files to build a comprehensive understanding of your project. This happens automatically without requiring any action from you. Kilo Code then indicates successful Memory Bank activation with `[Memory Bank: Active]` at the beginning of its response, followed by a brief summary of its understanding of your project. @@ -44,52 +44,59 @@ Files are organized in a hierarchical structure that builds a complete picture o ## Core Memory Bank Files ### brief.md -*This file is created and maintained manually by you* + +_This file is created and maintained manually by you_ + - The foundation of your project - High-level overview of what you're building - Core requirements and goals -Example: *"Building a React web app for inventory management with barcode scanning. The system needs to support multiple warehouses and integrate with our existing ERP system."* +Example: _"Building a React web app for inventory management with barcode scanning. The system needs to support multiple warehouses and integrate with our existing ERP system."_ Note: Kilo Code will not edit this file directly but may suggest improvements if it identifies ways to enhance your project brief. ### product.md + - Explains why the project exists - Describes the problems being solved - Outlines how the product should work - User experience goals -Example: *"The inventory system needs to support multiple warehouses and real-time updates. It solves the problem of inventory discrepancies by providing barcode scanning for accurate stock counts."* +Example: _"The inventory system needs to support multiple warehouses and real-time updates. It solves the problem of inventory discrepancies by providing barcode scanning for accurate stock counts."_ ### context.md + - The most frequently updated file - Contains current work focus and recent changes - Tracks active decisions and considerations - Next steps for development -Example: *"Currently implementing the barcode scanner component; last session completed the API integration. Next steps include adding error handling for network failures."* +Example: _"Currently implementing the barcode scanner component; last session completed the API integration. Next steps include adding error handling for network failures."_ ### architecture.md + - Documents the system architecture - Records key technical decisions - Lists design patterns in use - Explains component relationships - Critical implementation paths -Example: *"Using Redux for state management with a normalized store structure. The application follows a modular architecture with separate services for API communication, state management, and UI components."* +Example: _"Using Redux for state management with a normalized store structure. The application follows a modular architecture with separate services for API communication, state management, and UI components."_ ### tech.md + - Lists technologies and frameworks used - Describes development setup - Notes technical constraints - Records dependencies and tool configurations - Tool usage patterns -Example: *"React 18, TypeScript, Firebase, Jest for testing. Development requires Node.js 16+ and uses Vite as the build tool."* +Example: _"React 18, TypeScript, Firebase, Jest for testing. Development requires Node.js 16+ and uses Vite as the build tool."_ ## Additional Context Files Create additional files as needed to organize: + - Complex feature documentation - Integration specifications - API documentation @@ -99,7 +106,9 @@ Create additional files as needed to organize: These additional files help organize more detailed information that doesn't fit neatly into the core files. ### tasks.md -*Optional file for documenting repetitive tasks* + +_Optional file for documenting repetitive tasks_ + - Stores workflows for tasks that follow similar patterns - Documents which files need to be modified - Captures step-by-step procedures @@ -142,12 +151,12 @@ Provide a concise and comprehensive description of this project, highlighting it The initialization step is critically important as it establishes the foundation for all future interactions with your project. When you request initialization with the command `initialize memory bank`, Kilo Code will: 1. Perform an exhaustive analysis of your project, including: - - All source code files and their relationships - - Configuration files and build system setup - - Project structure and organization patterns - - Documentation and comments - - Dependencies and external integrations - - Testing frameworks and patterns + - All source code files and their relationships + - Configuration files and build system setup + - Project structure and organization patterns + - Documentation and comments + - Dependencies and external integrations + - Testing frameworks and patterns 2. Create comprehensive memory bank files in the `.kilocode/rules/memory-bank` folder 3. Provide a detailed summary of what it has understood about your project 4. Ask you to verify the accuracy of the generated files @@ -159,12 +168,14 @@ Take time to carefully review and correct the generated files after initializati #### Memory Bank Updates Memory Bank updates occur when: + 1. Kilo Code discovers new project patterns 2. After implementing significant changes 3. When you explicitly request with `update memory bank` 4. When context needs clarification To execute a Memory Bank update, Kilo Code will: + 1. Review ALL project files 2. Document the current state 3. Document insights and patterns @@ -175,6 +186,7 @@ You can direct Kilo Code to focus on specific information sources by using comma #### Regular Task Execution At the beginning of every task, Kilo Code: + 1. Reads ALL memory bank files 2. Includes `[Memory Bank: Active]` at the beginning of its response 3. Provides a brief summary of its understanding of your project @@ -187,13 +199,14 @@ At the end of a task, Kilo Code may suggest updating the memory bank if signific When you complete a repetitive task that follows a similar pattern each time, you can document it for future reference. This is particularly useful for tasks like adding features that follow existing patterns To document a task, use the command `add task` or `store this as a task`. Kilo Code will: + 1. Create or update the `tasks.md` file in the memory bank folder 2. Document the task using current context: - - Task name and description - - List of files that need to be modified - - Step-by-step workflow - - Important considerations - - Example implementation + - Task name and description + - List of files that need to be modified + - Step-by-step workflow + - Important considerations + - Example implementation When starting a new task, Kilo Code will check if it matches any documented tasks and follow the established workflow to ensure no steps are missed. @@ -215,6 +228,7 @@ These indicators appear at the beginning of Kilo Code's responses, providing imm ### Documentation Updates Memory Bank updates should automatically occur when: + - You discover new patterns in your project - After implementing significant changes - When you explicitly request with `update memory bank` @@ -243,24 +257,31 @@ This ensures that even with imperfect documentation, Kilo Code can still functio ## Frequently Asked Questions ### Where are the memory bank files stored? + The Memory Bank files are regular markdown files stored in your project repository, typically in a `.kilocode/rules/memory-bank/` folder. They're not hidden system files - they're designed to be part of your project documentation. ### How often should I update the memory bank? + Update the Memory Bank after significant milestones or changes in direction. For active development, updates every few sessions can be helpful. Use the "update memory bank" command when you want to ensure all context is preserved. ### Can I edit memory bank files manually? + Yes! While Kilo Code manages most of the files, you can edit any of them manually. The `brief.md` file is specifically designed to be maintained by you. Manual edits to other files will be respected by Kilo Code. ### What happens if memory bank files are missing? + If memory bank files are missing, Kilo Code will indicate this with `[Memory Bank: Missing]` at the beginning of its response and suggest initializing the memory bank. ### Does Memory Bank work with all AI models? + Memory Bank works with all AI models, but more powerful models will create more comprehensive and accurate memory bank files. Lightweight models may struggle with the resource-intensive process of analyzing and updating memory bank files. ### Can I use Memory Bank with multiple projects? + Yes! Each project has its own Memory Bank in its `.kilocode/rules/memory-bank/` folder. Kilo Code will automatically use the correct Memory Bank for each project. ### Doesn't Memory Bank use up my context window? + Yes, Memory Bank does consume some of your context window at the beginning of each session as it loads all memory bank files. However, this is a strategic tradeoff that significantly improves overall efficiency. By front-loading project context: - You eliminate repetitive explanations that would consume even more context over time @@ -272,12 +293,14 @@ Testing shows that while Memory Bank uses more tokens initially, it dramatically ## Best Practices ### Getting Started + - Start with a basic project brief and let the structure evolve - Let Kilo Code help create the initial structure - Review and adjust files as needed to match your workflow - Verify the accuracy of generated files after initialization ### Ongoing Work + - Let patterns emerge naturally as you work - Don't force documentation updates - they should happen organically - Trust the process - the value compounds over time @@ -285,12 +308,14 @@ Testing shows that while Memory Bank uses more tokens initially, it dramatically - Use the status indicators to confirm Memory Bank is active ### Documentation Flow + - `brief.md` is your foundation - `context.md` changes most frequently - All files collectively maintain project intelligence - Update after significant milestones or changes in direction ### Optimizing Memory Bank Performance + - Keep memory bank files concise and focused - Use additional files for detailed documentation - Update regularly but not excessively diff --git a/packages/kilo-docs/docs/advanced-usage/migrating-from-cursor-windsurf.md b/packages/kilo-docs/docs/advanced-usage/migrating-from-cursor-windsurf.md new file mode 100644 index 000000000..74dfeb62a --- /dev/null +++ b/packages/kilo-docs/docs/advanced-usage/migrating-from-cursor-windsurf.md @@ -0,0 +1,421 @@ +--- +sidebar_label: Migrating from Cursor or Windsurf +--- + +# Migrating from Cursor or Windsurf + +Quickly migrate your custom rules from Cursor or Windsurf to Kilo Code. The process typically takes just a few minutes per project. + +**Last Updated**: November 2025 + +## Why Kilo Code's Rules System? + +Kilo Code simplifies AI configuration while adding powerful new capabilities: + +- **Simple format**: Plain Markdown files—no YAML frontmatter or GUI configuration required +- **Mode-specific rules**: Different rules for different workflows (Code, Debug, Ask, custom modes) +- **Better version control**: All configuration lives in your repository as readable Markdown +- **More control**: Custom modes let you define specialized workflows with their own rules and permissions + +## Quick Migration Guide + +Choose your current tool: + +- [Migrating from Cursor](#migrating-from-cursor) → Skip to Cursor migration +- [Migrating from Windsurf](#migrating-from-windsurf) → Skip to Windsurf migration + +## Migrating from Cursor + +### What's Different in Kilo Code + +| Cursor | Kilo Code | Key Difference | +| ------------------------------------------- | ----------------------------------------- | ------------------------------------------- | +| `.cursor/rules/*.mdc` with YAML frontmatter | `.kilocode/rules/*.md` plain Markdown | No YAML metadata required | +| `alwaysApply: true/false` metadata | File location determines scope | Scope controlled by directory structure | +| `globs: ["*.ts"]` for file patterns | Mode-specific directories or custom modes | File patterns handled via custom modes | +| `description` for AI activation | Clear file names and organization | Relies on explicit file organization | +| Global rules in UI settings | `~/.kilocode/rules/*.md` files | Global rules stored as files in home folder | + +### Migration Steps + +**1. Identify your rules:** + +```bash +ls -la .cursor/rules/ # Project rules +ls -la .cursorrules # Legacy file (if present) +``` + +**2. Create Kilo Code directory:** + +```bash +mkdir -p .kilocode/rules +``` + +**3. Convert `.mdc` files to `.md`:** + +For each file in `.cursor/rules/`, remove the YAML frontmatter and keep just the Markdown content. + +**Cursor format:** + +```mdc +--- +description: TypeScript coding standards +globs: ["*.ts", "*.tsx"] +alwaysApply: false +--- + +# TypeScript Standards +- Always use TypeScript for new files +- Prefer functional components in React +``` + +**Kilo Code format:** + +```markdown +# TypeScript Standards + +- Always use TypeScript for new files +- Prefer functional components in React +``` + +**4. Migrate in one command:** + +```bash +# Copy all files +for file in .cursor/rules/*.mdc; do + basename="${file##*/}" + cp "$file" ".kilocode/rules/${basename%.mdc}.md" +done + +# Then manually edit each file to remove YAML frontmatter (the --- section at the top) +``` + +**5. Migrate global rules:** + +- Open `Cursor Settings → General → Rules for AI` +- Copy the text content +- Save to `~/.kilocode/rules/cursor-global.md` + +**6. Handle legacy `.cursorrules`:** + +```bash +cp .cursorrules .kilocode/rules/legacy-rules.md +``` + +### Converting Cursor's `globs` Patterns + +Cursor's `globs` field specifies which files a rule applies to. Kilo Code handles this through **mode-specific directories** instead. + +**Cursor approach:** + +```mdc +--- +globs: ["*.ts", "*.tsx"] +--- +Rules for TypeScript files... +``` + +**Kilo Code approach (Option 1 - Mode-specific directory):** + +```bash +mkdir -p .kilocode/rules-code +# Save TypeScript-specific rules here +``` + +**Kilo Code approach (Option 2 - Custom mode):** + +```yaml +# .kilocodemodes (at project root) +- slug: typescript + name: TypeScript + roleDefinition: You work on TypeScript files + groups: + - read + - [edit, { fileRegex: '\\.tsx?$' }] + - ask +``` + +Then place rules in `.kilocode/rules-typescript/` + +### Flattening Nested Cursor Rules + +Cursor supports nested `.cursor/rules/` directories. Kilo Code uses flat structure with descriptive names: + +```bash +# Cursor: .cursor/rules/backend/server/api-rules.mdc +# Kilo Code: .kilocode/rules/backend-server-api-rules.md +``` + +## Migrating from Windsurf + +### What's Different in Kilo Code + +| Windsurf | Kilo Code | Key Difference | +| -------------------------------------------------------------- | ------------------------------ | ------------------------------------------- | +| `.windsurf/rules/*.md` | `.kilocode/rules/*.md` | Same Markdown format | +| GUI configuration for activation modes | File location determines scope | Scope controlled by directory structure | +| "Always On" mode (GUI) | Place in `.kilocode/rules/` | Rules stored as files, not GUI settings | +| "Glob" mode (GUI) | Mode-specific directories | File patterns handled via mode directories | +| 12,000 character limit per rule | No hard limit | No character limit on rule files | +| Global rules in `~/.codeium/windsurf/memories/global_rules.md` | `~/.kilocode/rules/*.md` | Global rules in home folder, multiple files | + +### Migration Steps + +**1. Identify your rules:** + +```bash +ls -la .windsurf/rules/ # Project rules +ls -la .windsurfrules # Legacy file (if present) +``` + +**2. Create Kilo Code directory:** + +```bash +mkdir -p .kilocode/rules +``` + +**3. Copy files directly** (already Markdown): + +```bash +cp .windsurf/rules/*.md .kilocode/rules/ +``` + +**4. Migrate global rules:** + +```bash +cp ~/.codeium/windsurf/memories/global_rules.md ~/.kilocode/rules/global-rules.md +``` + +**5. Handle legacy `.windsurfrules`:** + +```bash +cp .windsurfrules .kilocode/rules/legacy-rules.md +``` + +**6. Split large rules if needed:** + +If you had rules approaching the 12,000 character limit, split them: + +```bash +# Instead of one large file: +# .windsurf/rules/all-conventions.md (11,500 chars) + +# Split into focused files: +# .kilocode/rules/api-conventions.md +# .kilocode/rules/testing-standards.md +# .kilocode/rules/code-style.md +``` + +### Converting Windsurf's Activation Modes + +Windsurf configures activation through the GUI. In Kilo Code, file organization replaces GUI configuration: + +| Windsurf GUI Mode | Kilo Code Equivalent | +| ------------------------ | ----------------------------------------------------------- | +| **Always On** | Place in `.kilocode/rules/` (default) | +| **Glob** (file patterns) | Mode-specific directory or custom mode | +| **Model Decision** | Clear file names by concern (e.g., `testing-guidelines.md`) | +| **Manual** | Organize with descriptive names | + +**Example - Converting a Glob rule:** + +If you had a rule in Windsurf with Glob mode set to `*.test.ts`, create a custom test mode: + +```yaml +# .kilocodemodes (at project root) +- slug: test + name: Testing + roleDefinition: You write and maintain tests + groups: + - read + - [edit, { fileRegex: '\\.(test|spec)\\.(ts|js)$' }] + - ask +``` + +Then place the rule in `.kilocode/rules-test/` + +## AGENTS.md Support + +All three tools support the `AGENTS.md` standard. If you have one, it works in Kilo Code automatically: + +```bash +# Verify it exists +ls -la AGENTS.md + +# That's it - Kilo Code loads it automatically (enabled by default) +``` + +**Important:** Use uppercase `AGENTS.md` (not `agents.md`). Kilo Code also accepts `AGENT.md` (singular) as a fallback. + +**Note:** Both `AGENTS.md` and `AGENT.md` are write-protected files in Kilo Code and require user approval to modify. + +## Understanding Mode-Specific Rules + +This is Kilo Code's unique feature that replaces both Cursor's `globs` and Windsurf's activation modes. + +### Directory Structure + +```bash +.kilocode/rules/ # Apply to ALL modes +.kilocode/rules-code/ # Only in Code mode +.kilocode/rules-debug/ # Only in Debug mode +.kilocode/rules-ask/ # Only in Ask mode +.kilocode/rules-{custom}/ # Only in your custom mode +``` + +### Real-World Example + +**From Cursor:** + +```mdc +--- +description: Testing best practices +globs: ["**/*.test.ts", "**/*.spec.ts"] +--- +# Testing Rules +- Write tests for all features +- Maintain >80% coverage +``` + +**To Kilo Code:** + +```bash +# 1. Create test mode directory +mkdir -p .kilocode/rules-test + +# 2. Save rule as plain Markdown +cat > .kilocode/rules-test/testing-standards.md << 'EOF' +# Testing Rules +- Write tests for all features +- Maintain >80% coverage +EOF + +# 3. Define the mode (optional - creates a custom mode) +# Add to .kilocode/config.yaml: +# modes: +# - slug: test +# name: Test Mode +# groups: [read, edit, ask] +``` + +## Post-Migration Checklist + +After migration: + +- [ ] **Verify rules loaded:** Click law icon (⚖️) in Kilo Code panel +- [ ] **Test rule application:** Ask Kilo Code to perform tasks following your rules +- [ ] **Organize rules:** Split large files, use clear names +- [ ] **Set up mode-specific rules:** Create directories for specialized workflows +- [ ] **Update team docs:** Document new `.kilocode/rules/` location +- [ ] **Commit to version control:** `git add .kilocode/` +- [ ] **Remove old directories:** Delete `.cursor/` or `.windsurf/` folders once verified + +## Troubleshooting + +### Rules Not Appearing + +**Check file location:** + +```bash +ls -la .kilocode/rules/ # Project rules +ls -la ~/.kilocode/rules/ # Global rules +``` + +**Verify file format:** + +- Can be any text file extension (`.md`, `.txt`, etc.) - binary files are automatically filtered out +- Remove all YAML frontmatter from Cursor files +- Ensure files are not cache/temp files (`.cache`, `.tmp`, `.log`, `.bak`, etc.) + +**Reload VS Code:** + +- `Cmd+R` (Mac) or `Ctrl+R` (Windows/Linux) +- Or: Command Palette → "Developer: Reload Window" + +### Cursor Metadata Lost + +Cursor's `globs`, `alwaysApply`, and `description` don't transfer automatically. Solutions: + +- **For file patterns:** Use mode-specific directories or custom modes +- **For always-on rules:** Place in `.kilocode/rules/` +- **For context-specific rules:** Use clear file names and organization + +### Windsurf Activation Modes Lost + +Windsurf's GUI activation modes (Always On/Glob/Model Decision/Manual) aren't stored in files. Solutions: + +- **Before migrating:** Document each rule's activation mode +- **After migrating:** Organize files accordingly in Kilo Code + +### Nested Rules Flattened + +Cursor's nested directories don't map to Kilo Code. Flatten with descriptive names: + +```bash +# Bad: .cursor/rules/backend/api/rules.mdc +# Good: .kilocode/rules/backend-api-rules.md +``` + +### AGENTS.md Not Loading + +- **Verify filename:** Must be `AGENTS.md` or `AGENT.md` (uppercase) +- **Check location:** Must be at project root +- **Check setting:** Verify "Use Agent Rules" is enabled in Kilo Code settings (enabled by default) +- **Reload:** Restart VS Code if needed + +## Advanced: Creating Custom Modes + +For complex workflows, define custom modes with their own rules and permissions: + +```yaml +# .kilocodemodes (at project root) +- slug: review + name: Code Review + roleDefinition: You review code and suggest improvements + groups: + - read + - ask + # Note: No edit permission - review mode is read-only + +- slug: docs + name: Documentation + roleDefinition: You write and maintain documentation + groups: + - read + - [edit, { fileRegex: '\\.md$', description: "Markdown files only" }] + - ask +``` + +Then create corresponding rule directories: + +```bash +mkdir -p .kilocode/rules-review +mkdir -p .kilocode/rules-docs +``` + +**Note:** `.kilocodemodes` can be in YAML (preferred) or JSON format. For global modes, edit the `custom_modes.yaml` file via Settings > Edit Global Modes. + +## Next Steps + +- [Learn about Custom Rules](/customization/custom-rules) +- [Explore Custom Modes](/customization/custom-modes) +- [Set up Custom Instructions](/customization/custom-instructions) +- [Join our Discord](https://kilo.ai/discord) for migration support + +## Additional Resources + +### Community Examples + +**Cursor users:** + +- [awesome-cursorrules](https://github.com/PatrickJS/awesome-cursorrules) - 700+ examples you can adapt + +**Windsurf users:** + +- [Official Rules Directory](https://windsurf.com/editor/directory) +- [windsurfrules](https://github.com/kinopeee/windsurfrules) + +**Cross-tool:** + +- [AGENTS.md Specification](https://agents.md) +- [dotagent](https://github.com/johnlindquist/dotagent) - Universal converter tool diff --git a/packages/kilo-docs/docs/advanced-usage/prompt-engineering.md b/packages/kilo-docs/docs/advanced-usage/prompt-engineering.md index b07f70b6c..ee3c4983a 100644 --- a/packages/kilo-docs/docs/advanced-usage/prompt-engineering.md +++ b/packages/kilo-docs/docs/advanced-usage/prompt-engineering.md @@ -1,55 +1,57 @@ # Prompt Engineering Tips -Prompt engineering is the art of crafting effective instructions for AI models like Kilo Code. Well-written prompts lead to better results, fewer errors, and a more efficient workflow. +Prompt engineering is the art of crafting effective instructions for AI models like Kilo Code. Well-written prompts lead to better results, fewer errors, and a more efficient workflow. ## General Principles -* **Be Clear and Specific:** Clearly state what you want Kilo Code to do. Avoid ambiguity. - * **Bad:** Fix the code. - * **Good:** Fix the bug in the `calculateTotal` function that causes it to return incorrect results. +- **Be Clear and Specific:** Clearly state what you want Kilo Code to do. Avoid ambiguity. -* **Provide Context:** Use [Context Mentions](/basic-usage/context-mentions) to refer to specific files, folders, or problems. - * **Good:** `@/src/utils.ts` Refactor the `calculateTotal` function to use async/await. + - **Bad:** Fix the code. + - **Good:** Fix the bug in the `calculateTotal` function that causes it to return incorrect results. -* **Break Down Tasks:** Divide complex tasks into smaller, well-defined steps. +- **Provide Context:** Use [Context Mentions](/basic-usage/context-mentions) to refer to specific files, folders, or problems. -* **Give Examples:** If you have a specific coding style or pattern in mind, provide examples. + - **Good:** `@/src/utils.ts` Refactor the `calculateTotal` function to use async/await. -* **Specify Output Format:** If you need the output in a particular format (e.g., JSON, Markdown), specify it in the prompt. +- **Break Down Tasks:** Divide complex tasks into smaller, well-defined steps. -* **Iterate:** Don't be afraid to refine your prompt if the initial results aren't what you expect. +- **Give Examples:** If you have a specific coding style or pattern in mind, provide examples. + +- **Specify Output Format:** If you need the output in a particular format (e.g., JSON, Markdown), specify it in the prompt. + +- **Iterate:** Don't be afraid to refine your prompt if the initial results aren't what you expect. ## Thinking vs. Doing It's often helpful to guide Kilo Code through a "think-then-do" process: 1. **Analyze:** Ask Kilo Code to analyze the current code, identify problems, or plan the approach. -2. **Plan:** Have Kilo Code outline the steps it will take to complete the task. -3. **Execute:** Instruct Kilo Code to implement the plan, one step at a time. -4. **Review:** Carefully review the results of each step before proceeding. +2. **Plan:** Have Kilo Code outline the steps it will take to complete the task. +3. **Execute:** Instruct Kilo Code to implement the plan, one step at a time. +4. **Review:** Carefully review the results of each step before proceeding. ## Using Custom Instructions You can provide custom instructions to further tailor Kilo Code's behavior. There are two types of custom instructions: -* **Global Custom Instructions:** Apply to all modes. -* **Mode-Specific Custom Instructions:** Apply only to a specific mode (e.g., Code, Architect, Ask, Debug, or a custom mode). +- **Global Custom Instructions:** Apply to all modes. +- **Mode-Specific Custom Instructions:** Apply only to a specific mode (e.g., Code, Architect, Ask, Debug, or a custom mode). Custom instructions are added to the system prompt, providing persistent guidance to the AI model. You can use these to: -* Enforce coding style guidelines. -* Specify preferred libraries or frameworks. -* Define project-specific conventions. -* Adjust Kilo Code's tone or personality. +- Enforce coding style guidelines. +- Specify preferred libraries or frameworks. +- Define project-specific conventions. +- Adjust Kilo Code's tone or personality. -See the [Custom Instructions](/advanced-usage/custom-instructions) section for more details. +See the [Custom Instructions](/customization/custom-instructions) section for more details. ## Handling Ambiguity If your request is ambiguous or lacks sufficient detail, Kilo Code might: -* **Make Assumptions:** It might proceed based on its best guess, which may not be what you intended. -* **Ask Follow-Up Questions:** It might use the `ask_followup_question` tool to clarify your request. +- **Make Assumptions:** It might proceed based on its best guess, which may not be what you intended. +- **Ask Follow-Up Questions:** It might use the `ask_followup_question` tool to clarify your request. It's generally better to provide clear and specific instructions from the start to avoid unnecessary back-and-forth. @@ -57,10 +59,10 @@ It's generally better to provide clear and specific instructions from the start If Kilo Code doesn't produce the desired results, you can provide feedback by: -* **Rejecting Actions:** Click the "Reject" button when Kilo Code proposes an action you don't want. -* **Providing Explanations:** When rejecting, explain *why* you're rejecting the action. This helps Kilo Code learn from its mistakes. -* **Rewording Your Request:** Try rephrasing your initial task or providing more specific instructions. -* **Manually Correcting:** If there are a few small issues, you can also directly modify the code before accepting the changes. +- **Rejecting Actions:** Click the "Reject" button when Kilo Code proposes an action you don't want. +- **Providing Explanations:** When rejecting, explain _why_ you're rejecting the action. This helps Kilo Code learn from its mistakes. +- **Rewording Your Request:** Try rephrasing your initial task or providing more specific instructions. +- **Manually Correcting:** If there are a few small issues, you can also directly modify the code before accepting the changes. ## Examples diff --git a/packages/kilo-docs/docs/basic-usage/git-commit-generation.md b/packages/kilo-docs/docs/basic-usage/git-commit-generation.md index ec5007149..716550878 100644 --- a/packages/kilo-docs/docs/basic-usage/git-commit-generation.md +++ b/packages/kilo-docs/docs/basic-usage/git-commit-generation.md @@ -9,6 +9,7 @@ This feature only analyzes **staged changes**. Make sure to stage your files usi ## How It Works The git commit message generator: + - Analyzes only your **staged changes** (not unstaged or untracked files) - Uses AI to understand the context and purpose of your changes - Creates descriptive commit messages that explain what was changed and why following the [Conventional Commits](https://www.conventionalcommits.org/) (by default, customizable) @@ -18,10 +19,9 @@ The git commit message generator: ### Generating a Commit Message 1. Stage your changes using `git add` or the VS Code git interface -2. In the VS Code Source Control panel, look for the `Kilo Code` logo next to the commit message field) +2. In the VS Code Source Control panel, look for the `Kilo Code` logo next to the commit message field 3. Click the logo to generate a commit message - The generated message will appear in the commit message field, ready for you to review and modify if needed. Generated commit message example @@ -37,6 +37,7 @@ By default, generated messages follow the Conventional Commits specification: ``` Common types include: + - `feat`: New features - `fix`: Bug fixes - `docs`: Documentation changes @@ -58,6 +59,7 @@ You can customize how commit messages are generated by modifying the prompt temp Commit message generation settings The default template creates conventional commit messages, but you can modify it to: + - Use different commit message formats - Include specific information relevant to your project - Follow your team's commit message conventions @@ -77,16 +79,19 @@ Consider creating a dedicated [API configuration profile](/features/api-configur ## Best Practices ### Staging Strategy + - Stage related changes together for more coherent commit messages - Avoid staging unrelated changes in a single commit - Use `git add -p` for partial file staging when needed ### Message Review + - Always review generated messages before committing - Edit messages to add context the AI might have missed - Ensure the message accurately describes the changes ### Custom Templates + - Tailor the prompt template to your project's needs - Include project-specific terminology or conventions - Add instructions for handling specific types of changes @@ -121,7 +126,9 @@ setup steps for new contributors ## Troubleshooting ### No Staged Changes + If the button doesn't appear or generation fails, ensure you have staged changes: + ```bash git add # or stage all changes @@ -129,13 +136,17 @@ git add . ``` ### Poor Message Quality + If generated messages aren't helpful: + - Review your staging strategy - don't stage unrelated changes together - Customize the prompt template with more specific instructions - Try a different AI model through API configuration ### Integration Issues + The feature integrates with VS Code's built-in git functionality. If you encounter issues: + - Ensure your repository is properly initialized - Check that VS Code can access your git repository - Verify git is installed and accessible from VS Code @@ -143,4 +154,4 @@ The feature integrates with VS Code's built-in git functionality. If you encount ## Related Features - [API Configuration Profiles](/features/api-configuration-profiles) - Use different models for commit generation -- [Settings Management](/features/settings-management) - Manage all your Kilo Code preferences \ No newline at end of file +- [Settings Management](/customization/settings-management) - Manage all your Kilo Code preferences diff --git a/packages/kilo-docs/docs/basic-usage/using-modes.md b/packages/kilo-docs/docs/basic-usage/using-modes.md index 8394f9a8c..75cb50359 100644 --- a/packages/kilo-docs/docs/basic-usage/using-modes.md +++ b/packages/kilo-docs/docs/basic-usage/using-modes.md @@ -19,72 +19,72 @@ Modes in Kilo Code are specialized personas that tailor the assistant's behavior Four ways to switch modes: 1. **Dropdown menu:** Click the selector to the left of the chat input - - Using the dropdown menu to switch modes + + Using the dropdown menu to switch modes 2. **Slash command:** Type `/architect`, `/ask`, `/debug`, or `/code` in the chat input - - Using slash commands to switch modes + + Using slash commands to switch modes 3. **Toggle command/Keyboard shortcut:** Use the keyboard shortcut below, applicable to your operating system. Each press cycles through the available modes in sequence, wrapping back to the first mode after reaching the end. - + | Operating System | Shortcut | - |------------------|----------| - | macOS | ⌘ + . | - | Windows | Ctrl + . | - | Linux | Ctrl + . | + | ---------------- | -------- | + | macOS | ⌘ + . | + | Windows | Ctrl + . | + | Linux | Ctrl + . | 4. **Accept suggestions:** Click on mode switch suggestions that Kilo Code offers when appropriate - - Accepting a mode switch suggestion from Kilo Code + +Accepting a mode switch suggestion from Kilo Code ## Built-in Modes ### Code Mode (Default) -| Aspect | Details | -|--------|---------| -| **Description** | A skilled software engineer with expertise in programming languages, design patterns, and best practices | -| **Tool Access** | Full access to all tool groups: `read`, `edit`, `browser`, `command`, `mcp` | -| **Ideal For** | Writing code, implementing features, debugging, and general development | -| **Special Features** | No tool restrictions—full flexibility for all coding tasks | +| Aspect | Details | +| -------------------- | -------------------------------------------------------------------------------------------------------- | +| **Description** | A skilled software engineer with expertise in programming languages, design patterns, and best practices | +| **Tool Access** | Full access to all tool groups: `read`, `edit`, `browser`, `command`, `mcp` | +| **Ideal For** | Writing code, implementing features, debugging, and general development | +| **Special Features** | No tool restrictions—full flexibility for all coding tasks | ### Ask Mode -| Aspect | Details | -|--------|---------| -| **Description** | A knowledgeable technical assistant focused on answering questions without changing your codebase | -| **Tool Access** | Limited access: `read`, `browser`, `mcp` only (cannot edit files or run commands) | -| **Ideal For** | Code explanation, concept exploration, and technical learning | -| **Special Features** | Optimized for informative responses without modifying your project | +| Aspect | Details | +| -------------------- | ------------------------------------------------------------------------------------------------- | +| **Description** | A knowledgeable technical assistant focused on answering questions without changing your codebase | +| **Tool Access** | Limited access: `read`, `browser`, `mcp` only (cannot edit files or run commands) | +| **Ideal For** | Code explanation, concept exploration, and technical learning | +| **Special Features** | Optimized for informative responses without modifying your project | ### Architect Mode -| Aspect | Details | -|--------|---------| -| **Description** | An experienced technical leader and planner who helps design systems and create implementation plans | -| **Tool Access** | Access to `read`, `browser`, `mcp`, and restricted `edit` (markdown files only) | -| **Ideal For** | System design, high-level planning, and architecture discussions | -| **Special Features** | Follows a structured approach from information gathering to detailed planning | +| Aspect | Details | +| -------------------- | ---------------------------------------------------------------------------------------------------- | +| **Description** | An experienced technical leader and planner who helps design systems and create implementation plans | +| **Tool Access** | Access to `read`, `browser`, `mcp`, and restricted `edit` (markdown files only) | +| **Ideal For** | System design, high-level planning, and architecture discussions | +| **Special Features** | Follows a structured approach from information gathering to detailed planning | ### Debug Mode -| Aspect | Details | -|--------|---------| -| **Description** | An expert problem solver specializing in systematic troubleshooting and diagnostics | -| **Tool Access** | Full access to all tool groups: `read`, `edit`, `browser`, `command`, `mcp` | -| **Ideal For** | Tracking down bugs, diagnosing errors, and resolving complex issues | +| Aspect | Details | +| -------------------- | ----------------------------------------------------------------------------------- | +| **Description** | An expert problem solver specializing in systematic troubleshooting and diagnostics | +| **Tool Access** | Full access to all tool groups: `read`, `edit`, `browser`, `command`, `mcp` | +| **Ideal For** | Tracking down bugs, diagnosing errors, and resolving complex issues | | **Special Features** | Uses a methodical approach of analyzing, narrowing possibilities, and fixing issues | ### Orchestrator Mode -| Aspect | Details | -|--------|---------| -| **Description** | A strategic workflow orchestrator who coordinates complex tasks by delegating them to appropriate specialized modes | -| **Tool Access** | Limited access to create new tasks and coordinate workflows | -| **Ideal For** | Breaking down complex projects into manageable subtasks assigned to specialized modes | -| **Special Features** | Uses the new_task tool to delegate work to other modes | +| Aspect | Details | +| -------------------- | ------------------------------------------------------------------------------------------------------------------- | +| **Description** | A strategic workflow orchestrator who coordinates complex tasks by delegating them to appropriate specialized modes | +| **Tool Access** | Limited access to create new tasks and coordinate workflows | +| **Ideal For** | Breaking down complex projects into manageable subtasks assigned to specialized modes | +| **Special Features** | Uses the new_task tool to delegate work to other modes | ## Custom Modes -Create your own specialized assistants by defining tool access, file permissions, and behavior instructions. Custom modes help enforce team standards or create purpose-specific assistants. See [Custom Modes documentation](/features/custom-modes) for setup instructions. +Create your own specialized assistants by defining tool access, file permissions, and behavior instructions. Custom modes help enforce team standards or create purpose-specific assistants. See [Custom Modes documentation](/customization/custom-modes) for setup instructions. diff --git a/packages/kilo-docs/docs/contributing/index.md b/packages/kilo-docs/docs/contributing/index.md index 62d29cd9d..f2996a5ea 100644 --- a/packages/kilo-docs/docs/contributing/index.md +++ b/packages/kilo-docs/docs/contributing/index.md @@ -82,7 +82,7 @@ git checkout -b your-branch-name Custom modes are a powerful way to extend Kilo Code's capabilities. To create and share a custom mode: -1. Follow the [Custom Modes documentation](/features/custom-modes) to create your mode +1. Follow the [Custom Modes documentation](/customization/custom-modes) to create your mode 2. Test your mode thoroughly diff --git a/packages/kilo-docs/docs/advanced-usage/custom-instructions.md b/packages/kilo-docs/docs/customization/custom-instructions.md similarity index 84% rename from packages/kilo-docs/docs/advanced-usage/custom-instructions.md rename to packages/kilo-docs/docs/customization/custom-instructions.md index 7727d1e17..eb02f6512 100644 --- a/packages/kilo-docs/docs/advanced-usage/custom-instructions.md +++ b/packages/kilo-docs/docs/customization/custom-instructions.md @@ -7,7 +7,7 @@ Custom Instructions allow you to personalize how Kilo Code behaves, providing sp Custom Instructions define specific Extension behaviors, preferences, and constraints beyond Kilo's basic role definition. Examples include coding style, documentation standards, testing requirements, and workflow guidelines. :::info Custom Instructions vs Rules -Custom Instructions are IDE-wide and are applied across all workspaces and maintain your preferences regardless of which project you're working on. Unlike Instructions, [Custom Rules](/advanced-usage/custom-rules.md) are project specific and allow you to setup workspace-based ruleset. +Custom Instructions are IDE-wide and are applied across all workspaces and maintain your preferences regardless of which project you're working on. Unlike Instructions, [Custom Rules](/customization/custom-rules) are project specific and allow you to setup workspace-based ruleset. ::: ## Setting Custom Instructions @@ -34,10 +34,9 @@ Mode-specific instructions can be set using the Modes Tab If the mode itself is global (not workspace-specific), any custom instructions you set for it will also apply globally for that mode across all workspaces. ::: - ## Related Features -- [Custom Modes](/docs/features/custom-modes) -- [Custom Rules](/advanced-usage/custom-rules) -- [Settings Management](/docs/features/settings-management) -- [Auto-Approval Settings](/docs/features/auto-approving-actions) +- [Custom Modes](/customization/custom-modes) +- [Custom Rules](/customization/custom-rules) +- [Settings Management](/customization/settings-management) +- [Auto-Approval Settings](/features/auto-approving-actions) diff --git a/packages/kilo-docs/docs/features/custom-modes.md b/packages/kilo-docs/docs/customization/custom-modes.md similarity index 100% rename from packages/kilo-docs/docs/features/custom-modes.md rename to packages/kilo-docs/docs/customization/custom-modes.md diff --git a/packages/kilo-docs/docs/advanced-usage/custom-rules.md b/packages/kilo-docs/docs/customization/custom-rules.md similarity index 89% rename from packages/kilo-docs/docs/advanced-usage/custom-rules.md rename to packages/kilo-docs/docs/customization/custom-rules.md index d96051d84..aada93fb8 100644 --- a/packages/kilo-docs/docs/advanced-usage/custom-rules.md +++ b/packages/kilo-docs/docs/customization/custom-rules.md @@ -16,7 +16,7 @@ Custom rules can be written in plain text, but Markdown format is recommended fo - Use Markdown headers (`#`, `##`, etc.) to define rule categories - Use lists (`-`, `*`) to enumerate specific items or constraints -- Use code blocks (``` ```) to include code examples when needed +- Use code blocks (` `) to include code examples when needed ## Rule Types @@ -78,9 +78,9 @@ Rules are loaded in the following priority order: 1. **Global rules** from `~/.kilocode/rules/` directory 2. **Project rules** from `.kilocode/rules/` directory 3. **Legacy fallback files** (for backward compatibility): - - `.roorules` - - `.clinerules` - - `.kilocoderules` (deprecated) + - `.roorules` + - `.clinerules` + - `.kilocoderules` (deprecated) When both global and project rules exist, they are combined with project rules taking precedence over global rules for conflicting directives. @@ -116,12 +116,14 @@ The easiest way to create and manage rules is through the built-in UI: To create rules manually: **For Project Rules:** + 1. Create the `.kilocode/rules/` directory if it doesn't already exist 2. Create a new Markdown file with a descriptive name in this directory 3. Write your rule using Markdown formatting 4. Save the file **For Global Rules:** + 1. Create the `~/.kilocode/rules/` directory if it doesn't already exist 2. Create a new Markdown file with a descriptive name in this directory 3. Write your rule using Markdown formatting @@ -135,6 +137,7 @@ Rules will be automatically applied to all future Kilo Code interactions. Any ne ```markdown # Tables + When printing tables, always add an exclamation mark to each column header ``` @@ -144,7 +147,9 @@ This simple rule instructs the AI to add exclamation marks to all table column h ```markdown # Restricted files + Files in the list contain sensitive data, they MUST NOT be read + - supersecrets.txt - credentials.json - .env @@ -168,14 +173,14 @@ Custom rules can be applied to a wide variety of scenarios: ## Examples of Custom Rules -* "Strictly follow code style guide [your project-specific code style guide]" -* "Always use spaces for indentation, with a width of 4 spaces" -* "Use camelCase for variable names" -* "Write unit tests for all new functions" -* "Explain your reasoning before providing code" -* "Focus on code readability and maintainability" -* "Prioritize using the most common library in the community" -* "When adding new features to websites, ensure they are responsive and accessible" +- "Strictly follow code style guide [your project-specific code style guide]" +- "Always use spaces for indentation, with a width of 4 spaces" +- "Use camelCase for variable names" +- "Write unit tests for all new functions" +- "Explain your reasoning before providing code" +- "Focus on code readability and maintainability" +- "Prioritize using the most common library in the community" +- "When adding new features to websites, ensure they are responsive and accessible" ## Best Practices @@ -204,15 +209,15 @@ If your custom rules aren't being properly followed: 1. **Check rule status in the UI**: Use the rules management interface to verify that your rules are active and properly loaded 1. **Verify rule formatting**: Ensure that your rules are properly formatted with clear Markdown structure 1. **Check rule locations**: Ensure that your rules are located in supported locations: - - Global rules: `~/.kilocode/rules/` directory - - Project rules: `.kilocode/rules/` directory - - Legacy files: `.kilocoderules`, `.roorules`, or `.clinerules` + - Global rules: `~/.kilocode/rules/` directory + - Project rules: `.kilocode/rules/` directory + - Legacy files: `.kilocoderules`, `.roorules`, or `.clinerules` 1. **Rule specificity**: Verify that the rules are specific and unambiguous 1. **Restart VS Code**: Restart VS Code to ensure the rules are properly loaded ## Related Features -- [Custom Modes](/docs/features/custom-modes) -- [Custom Instructions](/advanced-usage/custom-instructions) -- [Settings Management](/docs/features/settings-management) -- [Auto-Approval Settings](/docs/features/auto-approving-actions) +- [Custom Modes](/customization/custom-modes) +- [Custom Instructions](/customization/custom-instructions) +- [Settings Management](/customization/settings-management) +- [Auto-Approval Settings](/features/auto-approving-actions) diff --git a/packages/kilo-docs/docs/features/settings-management.md b/packages/kilo-docs/docs/customization/settings-management.md similarity index 55% rename from packages/kilo-docs/docs/features/settings-management.md rename to packages/kilo-docs/docs/customization/settings-management.md index e572e7bdd..cfe8188f0 100644 --- a/packages/kilo-docs/docs/features/settings-management.md +++ b/packages/kilo-docs/docs/customization/settings-management.md @@ -17,9 +17,9 @@ You can find these options at the bottom of the Kilo Code settings page, accessi Clicking the **Export** button saves your current Kilo Code settings to a JSON file. -* **What's Exported:** The file includes your configured API Provider Profiles and Global Settings (UI preferences, mode configurations, context settings, etc.). -* **Security Warning:** The exported JSON file contains **all** your configured API Provider Profiles and Global Settings. Crucially, this includes **API keys in plaintext**. Treat this file as highly sensitive. Do not share it publicly or with untrusted individuals, as it grants access to your API accounts. -* **Process:** +- **What's Exported:** The file includes your configured API Provider Profiles and Global Settings (UI preferences, mode configurations, context settings, etc.). +- **Security Warning:** The exported JSON file contains **all** your configured API Provider Profiles and Global Settings. Crucially, this includes **API keys in plaintext**. Treat this file as highly sensitive. Do not share it publicly or with untrusted individuals, as it grants access to your API accounts. +- **Process:** 1. Click **Export**. 2. A file save dialog appears, suggesting `kilo-code-settings.json` as the filename (usually in your `~/Documents` folder). 3. Choose a location and save the file. @@ -30,31 +30,33 @@ This creates a backup of your configuration or a file you can share. Clicking the **Import** button allows you to load settings from a previously exported JSON file. -* **Process:** +- **Process:** 1. Click **Import**. 2. A file open dialog appears. Select the `kilo-code-settings.json` file (or similarly named file) you want to import. 3. Kilo Code reads the file, validates its contents against the expected schema, and applies the settings. -* **Merging:** Importing settings **merges** the configurations. It adds new API profiles and updates existing ones and global settings based on the file content. It does **not** delete configurations present in your current setup but missing from the imported file. -* **Validation:** Only valid settings matching the internal schema can be imported, preventing configuration errors. A success notification appears upon completion. +- **Merging:** Importing settings **merges** the configurations. It adds new API profiles and updates existing ones and global settings based on the file content. It does **not** delete configurations present in your current setup but missing from the imported file. +- **Validation:** Only valid settings matching the internal schema can be imported, preventing configuration errors. A success notification appears upon completion. ## Reset Settings Clicking the **Reset** button completely clears all Kilo Code configuration data and returns the extension to its default state. This is a destructive action intended for troubleshooting or starting fresh. -* **Warning:** This action is **irreversible**. It permanently deletes all API configurations (including keys stored in secret storage), custom modes, global settings, and task history. +- **Warning:** This action is **irreversible**. It permanently deletes all API configurations (including keys stored in secret storage), custom modes, global settings, and task history. + +- **Process:** -* **Process:** 1. Click the red **Reset** button. 2. A confirmation dialog appears, warning that the action cannot be undone. 3. Click "Yes" to confirm. -* **What is Reset:** - * **API Provider Profiles:** All configurations are deleted from settings and secret storage. - * **Global Settings:** All preferences (UI, modes, approvals, browser, etc.) are reset to defaults. - * **Custom Modes:** All user-defined modes are deleted. - * **Secret Storage:** All API keys and other secrets managed by Kilo Code are cleared. - * **Task History:** The current task stack is cleared. +- **What is Reset:** -* **Result:** Kilo Code returns to its initial state, as if freshly installed, with default settings and no user configurations. + - **API Provider Profiles:** All configurations are deleted from settings and secret storage. + - **Global Settings:** All preferences (UI, modes, approvals, browser, etc.) are reset to defaults. + - **Custom Modes:** All user-defined modes are deleted. + - **Secret Storage:** All API keys and other secrets managed by Kilo Code are cleared. + - **Task History:** The current task stack is cleared. -Use this option only if you are certain you want to remove all Kilo Code data or if instructed during troubleshooting. Consider exporting your settings first if you might want to restore them later. \ No newline at end of file +- **Result:** Kilo Code returns to its initial state, as if freshly installed, with default settings and no user configurations. + +Use this option only if you are certain you want to remove all Kilo Code data or if instructed during troubleshooting. Consider exporting your settings first if you might want to restore them later. diff --git a/packages/kilo-docs/docs/features/skills.md b/packages/kilo-docs/docs/customization/skills.md similarity index 97% rename from packages/kilo-docs/docs/features/skills.md rename to packages/kilo-docs/docs/customization/skills.md index ed3238841..d0c58aeb5 100644 --- a/packages/kilo-docs/docs/features/skills.md +++ b/packages/kilo-docs/docs/customization/skills.md @@ -285,6 +285,6 @@ Skills are simple Markdown files with frontmatter. Start with your existing prom ## Related -- [Custom Modes](custom-modes) - Create custom modes that can use specific skills -- [Custom Instructions](../advanced-usage/custom-instructions) - Global instructions vs. skill-based instructions -- [Custom Rules](../advanced-usage/custom-rules) - Project-level rules complementing skills +- [Custom Modes](/customization/custom-modes) - Create custom modes that can use specific skills +- [Custom Instructions](/customization/custom-instructions) - Global instructions vs. skill-based instructions +- [Custom Rules](/customization/custom-rules) - Project-level rules complementing skills diff --git a/packages/kilo-docs/docs/features/slash-commands/workflows.mdx b/packages/kilo-docs/docs/customization/workflows.mdx similarity index 99% rename from packages/kilo-docs/docs/features/slash-commands/workflows.mdx rename to packages/kilo-docs/docs/customization/workflows.mdx index 899dea4a5..cc6f75fd6 100644 --- a/packages/kilo-docs/docs/features/slash-commands/workflows.mdx +++ b/packages/kilo-docs/docs/customization/workflows.mdx @@ -10,6 +10,7 @@ Workflows automate repetitive tasks by defining step-by-step instructions for Ki ## Creating Workflows Workflows are markdown files stored in `.kilocode/workflows/`: + - **Global workflows**: `~/.kilocode/workflows/` (available in all projects) - **Project workflows**: `[project]/.kilocode/workflows/` (project-specific) @@ -22,6 +23,7 @@ Workflows are markdown files stored in `.kilocode/workflows/`: ### Workflow Capabilities Workflows can leverage: + - [Built-in tools](/features/tools/tool-use-overview): [`read_file()`](/features/tools/read-file), [`search_files()`](/features/tools/search-files), [`execute_command()`](/features/tools/execute-command) - CLI tools: `gh`, `docker`, `npm`, custom scripts - [MCP integrations](/features/mcp/overview): Slack, databases, APIs @@ -30,6 +32,7 @@ Workflows can leverage: ## Common Workflow Patterns **Release Management** + ```markdown 1. Gather merged PRs since last release 2. Generate changelog from commit messages @@ -39,6 +42,7 @@ Workflows can leverage: ``` **Project Setup** + ```markdown 1. Clone repository template 2. Install dependencies (`npm install`, `pip install -r requirements.txt`) @@ -48,6 +52,7 @@ Workflows can leverage: ``` **Code Review Preparation** + ```markdown 1. Search for TODO comments and debug statements 2. Run linting and formatting @@ -73,6 +78,7 @@ You are helping submit a pull request. Follow these steps: 5. Use `ask_followup_question` to get the PR title and description from the user Parameters needed (ask if not provided): + - Branch name - Reviewers to assign ``` diff --git a/packages/kilo-docs/docs/faq.md b/packages/kilo-docs/docs/faq.md index 5037a5b66..d2b2b5397 100644 --- a/packages/kilo-docs/docs/faq.md +++ b/packages/kilo-docs/docs/faq.md @@ -19,7 +19,7 @@ Kilo Code is an open-source AI agent extension for Visual Studio Code. It helps Kilo Code uses large language models (LLMs) to understand your requests and translate them into actions. It can: -- Read and write files in your project. +- Read, write, and delete files in your project. - Execute commands in your VS Code terminal. - Perform web browsing (if enabled). - Use external tools via the Model Context Protocol (MCP). @@ -113,7 +113,7 @@ Open the Kilo Code panel () and ty - **Architect:** For planning and technical leadership. - **Ask:** For answering questions and providing information. - **Debug:** For systematic problem diagnosis. - You can also create [Custom Modes](/features/custom-modes). + You can also create [Custom Modes](/customization/custom-modes). ### How do I switch between modes? @@ -175,7 +175,7 @@ Yes, you can create your own MCP servers to add custom functionality to Kilo Cod - Check your internet connection. - Check the status of your chosen API provider. - Try restarting VS Code. -- If the problem persists, report the issue on [GitHub](https://github.com/Kilo-Org/kilocode/issues) or [Discord](https://kilocode.ai/discord). +- If the problem persists, report the issue on [GitHub](https://github.com/Kilo-Org/kilocode/issues) or [Discord](https://kilo.ai/discord). ### I'm seeing an error message. What does it mean? diff --git a/packages/kilo-docs/docs/features/api-configuration-profiles.md b/packages/kilo-docs/docs/features/api-configuration-profiles.md index d3ca73398..66cf9676f 100644 --- a/packages/kilo-docs/docs/features/api-configuration-profiles.md +++ b/packages/kilo-docs/docs/features/api-configuration-profiles.md @@ -98,7 +98,7 @@ API keys are stored securely in VSCode's Secret Storage and are never exposed in ## Related Features -- Works with [custom modes](/features/custom-modes) you create +- Works with [custom modes](/customization/custom-modes) you create - Integrates with [local models](/advanced-usage/local-models) for offline work - Supports [temperature settings](/features/model-temperature) per mode - Enhances cost management with [rate limits and usage tracking](/advanced-usage/rate-limits-costs) diff --git a/packages/kilo-docs/docs/features/auto-launch-configuration.md b/packages/kilo-docs/docs/features/auto-launch-configuration.md index 02b860e1f..ffbb72171 100644 --- a/packages/kilo-docs/docs/features/auto-launch-configuration.md +++ b/packages/kilo-docs/docs/features/auto-launch-configuration.md @@ -48,7 +48,7 @@ This happens seamlessly in the background, requiring no manual intervention. - `"ask"` - Questions and explanations - `"debug"` - Problem diagnosis and troubleshooting - `"test"` - Testing-focused workflows - - Custom mode slugs (if you have [custom modes](/features/custom-modes)) + - Custom mode slugs (if you have [custom modes](/customization/custom-modes)) ## Example Configurations diff --git a/packages/kilo-docs/docs/features/model-temperature.md b/packages/kilo-docs/docs/features/model-temperature.md index f4780edf2..194115b1c 100644 --- a/packages/kilo-docs/docs/features/model-temperature.md +++ b/packages/kilo-docs/docs/features/model-temperature.md @@ -11,11 +11,11 @@ Temperature is a setting (usually between 0.0 and 2.0) that controls how random :::info Temperature and Code: Common Misconceptions Temperature controls output randomness, not code quality or accuracy directly. Key points: -* **Low Temperature (near 0.0):** Produces predictable, consistent code. Good for simple tasks, but can be repetitive and lack creativity. It doesn't guarantee *better* code. -* **High Temperature:** Increases randomness, potentially leading to creative solutions but also more errors or nonsensical code. It doesn't guarantee *higher-quality* code. -* **Accuracy:** Code accuracy depends on the model's training and prompt clarity, not temperature. -* **Temperature 0.0:** Useful for consistency, but limits exploration needed for complex problems. -::: +- **Low Temperature (near 0.0):** Produces predictable, consistent code. Good for simple tasks, but can be repetitive and lack creativity. It doesn't guarantee _better_ code. +- **High Temperature:** Increases randomness, potentially leading to creative solutions but also more errors or nonsensical code. It doesn't guarantee _higher-quality_ code. +- **Accuracy:** Code accuracy depends on the model's training and prompt clarity, not temperature. +- **Temperature 0.0:** Useful for consistency, but limits exploration needed for complex problems. + ::: ## Default Values in Kilo Code @@ -31,10 +31,10 @@ Some specialized models don't support temperature adjustments at all, in which c Here are some examples of temperature settings that might work well for different tasks: -* **Code Mode (0.0-0.3):** For writing precise, correct code with consistent, deterministic results -* **Architect Mode (0.4-0.7):** For brainstorming architecture or design solutions with balanced creativity and structure -* **Ask Mode (0.7-1.0):** For explanations or open-ended questions requiring diverse and insightful responses -* **Debug Mode (0.0-0.3):** For troubleshooting bugs with consistent precision +- **Code Mode (0.0-0.3):** For writing precise, correct code with consistent, deterministic results +- **Architect Mode (0.4-0.7):** For brainstorming architecture or design solutions with balanced creativity and structure +- **Ask Mode (0.7-1.0):** For explanations or open-ended questions requiring diverse and insightful responses +- **Debug Mode (0.0-0.3):** For troubleshooting bugs with consistent precision These are starting points – it's important to [experiment with different settings](#experimentation) to find what works best for your specific needs and preferences. @@ -66,11 +66,11 @@ This approach optimizes model behavior for specific tasks without manual adjustm Kilo Code implements temperature handling with these considerations: -* User-defined settings take priority over defaults -* Provider-specific behaviors are respected -* Model-specific limitations are enforced: - * Thinking-enabled models require a fixed temperature of 1.0 - * Some models don't support temperature adjustments +- User-defined settings take priority over defaults +- Provider-specific behaviors are respected +- Model-specific limitations are enforced: + - Thinking-enabled models require a fixed temperature of 1.0 + - Some models don't support temperature adjustments ## Experimentation @@ -89,5 +89,5 @@ Remember that different models may respond differently to the same temperature v ## Related Features - Works with all [API providers](/providers/openai) supported by Kilo Code -- Complements [custom instructions](/advanced-usage/custom-instructions) for fine-tuning responses -- Works alongside [custom modes](/features/custom-modes) you create \ No newline at end of file +- Complements [custom instructions](/customization/custom-instructions) for fine-tuning responses +- Works alongside [custom modes](/customization/custom-modes) you create diff --git a/packages/kilo-docs/docs/index.mdx b/packages/kilo-docs/docs/index.mdx index aefbf17e8..451d782d1 100644 --- a/packages/kilo-docs/docs/index.mdx +++ b/packages/kilo-docs/docs/index.mdx @@ -2,8 +2,14 @@ sidebar_label: Welcome --- -import { DISCORD_URL, REDDIT_URL, GITHUB_ISSUES_MAIN_URL, GITHUB_FEATURES_URL, YOUTUBE_URL } from '@site/src/constants.ts' -import Image from '@site/src/components/Image'; +import { + DISCORD_URL, + REDDIT_URL, + GITHUB_ISSUES_MAIN_URL, + GITHUB_FEATURES_URL, + YOUTUBE_URL, +} from "@site/src/constants.ts" +import Image from "@site/src/components/Image" # Kilo Code Documentation @@ -26,7 +32,11 @@ Kilo Code **accelerates** development with AI-driven code generation and task au ## Features -GIF showing some of the capabilities of Kilo Code +GIF showing some of the capabilities of Kilo Code ### Basics @@ -39,16 +49,20 @@ Use [the chat interface](/basic-usage/the-chat-interface) to tell Kilo Code what ### Using Kilo Code #### Multiple Modes + Kilo Code adapts to your needs with specialized [modes](/basic-usage/using-modes): + - [**Code Mode:**](/basic-usage/using-modes#code-mode-default) For general-purpose coding tasks - [**Architect Mode:**](/basic-usage/using-modes#architect-mode) For planning and technical leadership - [**Ask Mode:**](/basic-usage/using-modes#ask-mode) For answering questions and providing information - [**Debug Mode:**](/basic-usage/using-modes#debug-mode) For systematic problem diagnosis -- **[Custom Modes](/features/custom-modes):** Create unlimited specialized personas for security auditing, performance optimization, documentation, or any other task +- **[Custom Modes](/customization/custom-modes):** Create unlimited specialized personas for security auditing, performance optimization, documentation, or any other task #### Core Tools + Kilo Code comes with powerful [tools](/features/tools/tool-use-overview) that can: -- [Read](/features/tools/read-file) and [write](/features/tools/write-to-file) files in your project + +- [Read](/features/tools/read-file), [write](/features/tools/write-to-file), and [delete](/features/tools/delete-file) files in your project - [Execute commands](/features/tools/execute-command) in your VS Code terminal - [Control a web browser](/features/tools/browser-action) - [Ask follow-up questions](/features/tools/ask-followup-question) @@ -57,27 +71,32 @@ Kilo Code comes with powerful [tools](/features/tools/tool-use-overview) that ca See the complete [Tools Reference](/features/tools/tool-use-overview) for all available tools. ### Extending Kilo Code + - **[MCP (Model Context Protocol)](/features/mcp/overview):** Add unlimited custom tools, integrate with external APIs, connect to databases, or create specialized development tools - **[Local Models](/advanced-usage/local-models):** Run Kilo Code with local AI models for offline use or enhanced privacy ### Customizing Kilo Code + Make Kilo Code work your way with: -- [Settings Management](/features/settings-management) for configuring your experience -- [Custom Modes](/features/custom-modes) for specialized tasks -- [Custom Rules](/advanced-usage/custom-rules) for project-specific rules -- [Custom Instructions](/advanced-usage/custom-instructions) for global plugin-wide instructions + +- [Settings Management](/customization/settings-management) for configuring your experience +- [Custom Modes](/customization/custom-modes) for specialized tasks +- [Custom Rules](/customization/custom-rules) for project-specific rules +- [Custom Instructions](/customization/custom-instructions) for global plugin-wide instructions - [API Configuration Profiles](/features/api-configuration-profiles) for different model providers - [Auto-Approval Settings](/features/auto-approving-actions) for faster workflows ## Resources ### Documentation + - [Using Kilo Code](/basic-usage/the-chat-interface) - Learn the basics - [Core Concepts](/features/auto-approving-actions) - Master key features - [Advanced Usage](/advanced-usage/prompt-engineering) - Take your skills further - [Frequently Asked Questions](/faq) - Get answers to common questions ### Community + - **Discord:** Join our Discord server for real-time help and discussions - **Reddit:** Visit our subreddit to share experiences and tips - **YouTube:** Check out our YouTube to learn hands on skills when using Kilo Code diff --git a/packages/kilo-docs/docs/tips-and-tricks.md b/packages/kilo-docs/docs/tips-and-tricks.md index 92549c31e..0e170d957 100644 --- a/packages/kilo-docs/docs/tips-and-tricks.md +++ b/packages/kilo-docs/docs/tips-and-tricks.md @@ -5,7 +5,7 @@ A collection of quick tips to help you get the most out of Kilo Code. - Drag Kilo Code to the [Secondary Sidebar](https://code.visualstudio.com/api/ux-guidelines/sidebars#secondary-sidebar) so you can see the Explorer, Search, Source Control, etc. - Once you have Kilo Code in a separate sidebar from the file explorer, you can drag files from the explorer into the chat window (and even multiple at once). Just make sure to hold down the shift key after you start dragging the files. - If you're not using [MCP](/features/mcp/overview), turn it off in the Prompts tab to significantly cut down the size of the system prompt. -- To keep your [custom modes](/features/custom-modes) on track, limit the types of files that they're allowed to edit. +- To keep your [custom modes](/customization/custom-modes) on track, limit the types of files that they're allowed to edit. - If you hit the dreaded `input length and max tokens exceed context limit` error, you can recover by deleting a message, rolling back to a previous checkpoint, or switching over to a model with a long context window like Gemini for a message. - In general, be thoughtful about your `Max Tokens` setting for thinking models. Every token you allocate to that takes away from space available to store conversation history. Consider only using high `Max Tokens` / `Max Thinking Tokens` settings with modes like Architect and Debug, and keeping Code mode at 16k max tokens or less. - If there's a real world job posting for something you want a custom mode to do, try asking Code mode to `Create a custom mode based on the job posting at @[url]` @@ -14,6 +14,6 @@ A collection of quick tips to help you get the most out of Kilo Code. - Add your own tips by clicking "Edit this page" below! - To manage large files and reduce context/resource usage, adjust the `File read auto-truncate threshold` setting. This setting controls the number of lines read from a file in one batch. Lower values can improve performance when working with very large files, but may require more read operations. You can find this setting in the Kilo Code settings under 'Advanced Settings'. -| Browser Tab | Auto-Approve Tab | Display Tab | -|---------|---------|---------| +| Browser Tab | Auto-Approve Tab | Display Tab | +| ------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- | | [![KiloCode Demo 1](https://img.youtube.com/vi/VMPKXt8k050/maxresdefault.jpg)](https://youtube.com/shorts/VMPKXt8k050?feature=shared) | [![KiloCode Demo 2](https://img.youtube.com/vi/NBccFnYDQ-k/maxresdefault.jpg)](https://youtube.com/shorts/NBccFnYDQ-k?feature=shared) | [![KiloCode Demo 3](https://img.youtube.com/vi/qYrT2pbfS7E/maxresdefault.jpg)](https://youtube.com/shorts/qYrT2pbfS7E?feature=shared) | diff --git a/packages/kilo-docs/sidebars.ts b/packages/kilo-docs/sidebars.ts index 89762c01a..a658c27c4 100644 --- a/packages/kilo-docs/sidebars.ts +++ b/packages/kilo-docs/sidebars.ts @@ -129,21 +129,24 @@ const sidebars: SidebarsConfig = { "plans/migration", ], }, + { + type: "category", + label: "Customization", + items: [ + "customization/custom-modes", + "customization/custom-rules", + "customization/custom-instructions", + "customization/workflows", + "customization/settings-management", + "customization/skills", + ], + }, { type: "category", label: "Advanced Usage", items: [ "advanced-usage/prompt-engineering", - { - type: "category", - label: "Customizing Kilo Code", - items: [ - "advanced-usage/custom-rules", - "advanced-usage/custom-instructions", - "advanced-usage/migrating-from-cursor-windsurf", - "features/slash-commands/workflows", - ], - }, + "advanced-usage/migrating-from-cursor-windsurf", { type: "category", label: "Advanced Context Features", @@ -178,11 +181,6 @@ const sidebars: SidebarsConfig = { "features/experimental/experimental-features", ], }, - { - type: "category", - label: "Customization", - items: ["features/settings-management", "features/custom-modes", "features/skills"], - }, { type: "category", label: "Extending Kilo Code",