kiro-agent-team 1.0.0

package/.kiro/documentation/docs_cli_chat_subagents.md

@@ -0,0 +1,77 @@
+# Subagents
+Subagents are specialized agents that can autonomously execute complex tasks on your behalf. They have their own context, tool access, and decision-making capabilities, making them ideal for sophisticated multi-step operations.
+## Key capabilities[](https://kiro.dev/docs/cli/chat/subagents/#key-capabilities)
+  * **Autonomous execution** - Run independently with their own context, with the level of autonomy depending on agent configuration
+  * **Live progress tracking** - Monitor real-time status updates as subagents work through tasks
+  * **Core tool access** - Read files, execute commands, write files, and use MCP tools
+  * **Parallel execution** - Run multiple subagents simultaneously for efficient task execution
+  * **Result aggregation** - Results automatically returned to the main agent when complete
+
+
+## Default subagent[](https://kiro.dev/docs/cli/chat/subagents/#default-subagent)
+Kiro includes a default subagent that can handle general-purpose tasks. When you assign a task to a subagent, the default subagent is used unless you specify a custom agent configuration.
+## Custom subagents[](https://kiro.dev/docs/cli/chat/subagents/#custom-subagents)
+You can spawn subagents using your own agent configurations. This allows you to create specialized subagents tailored to specific workflows:
+bash
+```
+
+> Use the backend agent to refactor the payment module
+
+
+```
+
+To use a custom agent as a subagent, reference it by name when assigning tasks. The subagent will inherit the tool access and settings from that agent's configuration.
+## How subagents work[](https://kiro.dev/docs/cli/chat/subagents/#how-subagents-work)
+  1. **Task assignment** - You describe a task, and Kiro determines if a subagent is appropriate
+  2. **Subagent initialization** - The subagent is created with its own context and tool access based on its agent configuration
+  3. **Autonomous execution** - The subagent works through the task independently, though it may pause to request user approval for certain tool permissions
+  4. **Progress updates** - You receive live progress updates showing current work
+  5. **Result return** - When complete, results are returned to the main agent
+
+
+## Tool availability[](https://kiro.dev/docs/cli/chat/subagents/#tool-availability)
+Subagents run in a separate runtime environment. Some tools available in normal chat are not yet implemented in subagents.
+**Available tools:**
+  * `read` - Read files and directories
+  * `write` - Create and edit files
+  * `shell` - Execute bash commands
+  * MCP tools
+
+
+**Not available:**
+  * `web_search` - Web research
+  * `web_fetch` - Fetch URLs
+  * `introspect` - CLI info
+  * `thinking` - Reasoning tool
+  * `todo_list` - Task tracking
+  * `use_aws` - AWS commands
+  * `grep` - Search file contents
+  * `glob` - Find files by pattern
+
+
+**Agent configuration**
+If your custom agent configuration includes tools that aren't available in subagents, those tools will simply be unavailable when the agent runs as a subagent. The agent will still function with the available tools.
+## Best practices[](https://kiro.dev/docs/cli/chat/subagents/#best-practices)
+  1. **Use for complex tasks** - Most valuable for multi-step operations that benefit from isolation
+  2. **Provide clear instructions** - Specific task descriptions lead to better results
+  3. **Monitor progress** - Check on long-running subagents periodically
+  4. **Review results** - Verify subagent output before acting on recommendations
+
+
+## Troubleshooting[](https://kiro.dev/docs/cli/chat/subagents/#troubleshooting)
+Issue | Solution  
+---|---  
+Subagent not starting | Verify the task description is clear and actionable  
+Missing tool access | Check if the required tool is available in subagent runtime (see table above)  
+Incomplete results | Provide more specific instructions or break into smaller tasks  
+Page updated: December 18, 2025
+[Model selection](https://kiro.dev/docs/cli/chat/model-selection/)
+[Planning Agent](https://kiro.dev/docs/cli/chat/planning-agent/)
+On this page
+  * [Key capabilities](https://kiro.dev/docs/cli/chat/subagents/#key-capabilities)
+  * [Default subagent](https://kiro.dev/docs/cli/chat/subagents/#default-subagent)
+  * [Custom subagents](https://kiro.dev/docs/cli/chat/subagents/#custom-subagents)
+  * [How subagents work](https://kiro.dev/docs/cli/chat/subagents/#how-subagents-work)
+  * [Tool availability](https://kiro.dev/docs/cli/chat/subagents/#tool-availability)
+  * [Best practices](https://kiro.dev/docs/cli/chat/subagents/#best-practices)
+  * [Troubleshooting](https://kiro.dev/docs/cli/chat/subagents/#troubleshooting)

package/.kiro/documentation/docs_cli_code-intelligence.md

@@ -0,0 +1,251 @@
+# Code Intelligence
+## Overview[](https://kiro.dev/docs/cli/code-intelligence/#overview)
+Code Intelligence integrates Language Server Protocol (LSP) into Kiro CLI to enable semantic understanding of your codebase for the Kiro agent, similar to how extensions provide capabilities in your IDE. It comes pre-configured with 7 languages (TypeScript, Rust, Python, Go, Java, Ruby, C/C++) but can be expanded to any language by adding custom LSP configurations to `.kiro/settings/lsp.json` in your project root. After running `/code init`, you can search symbols, find references, navigate definitions, rename across files, and get diagnostics through natural language queries.
+### How it works[](https://kiro.dev/docs/cli/code-intelligence/#how-it-works)
+Kiro CLI spawns LSP server processes in the background that communicate via JSON-RPC over stdio. When you initialize a workspace, it detects languages from project markers (like `package.json`, `Cargo.toml`) and file extensions, then starts the appropriate language servers. These servers continuously analyze your code and maintain an index of symbols, types, and references. When you make queries, Kiro translates your natural language into LSP protocol requests, sends them to the relevant server, and formats the responses back into readable output.
+Here's how you can enable Kiro CLI to use LSP servers:
+  1. Install language servers
+  2. Enable the LSP integration
+  3. Ask code related questions to use language servers
+
+
+## Installing language servers[](https://kiro.dev/docs/cli/code-intelligence/#installing-language-servers)
+**Supported Languages**
+Language | Extensions | Server | Install Command  
+---|---|---|---  
+TypeScript/JavaScript | .ts, .js, .tsx, .jsx | typescript-language-server | `npm install -g typescript-language-server typescript`  
+Rust | .rs | rust-analyzer | `rustup component add rust-analyzer`  
+Python | .py | jedi-language-server | `npm install -g pyright or pip install pyright`  
+Go | .go | gopls | `go install golang.org/x/tools/gopls@latest`  
+Java | .java | jdtls | `brew install jdtls (macOS)`  
+Ruby | .rb | solargraph | `gem install solargraph`  
+C/C++ | .c, .cpp, .h, .hpp | clangd | `brew install llvm (macOS) or apt install clangd (Linux)`  
+## Initialize Code Intelligence[](https://kiro.dev/docs/cli/code-intelligence/#initialize-code-intelligence)
+**Workspace-scoped configuration**
+Code intelligence is configured per workspace, not globally. Each project maintains its own LSP settings independently.
+Run this slash command in your project root:
+```
+
+/code init
+
+
+```
+
+This creates `.kiro/settings/lsp.json` configuration and starts language servers.
+What you'll see:
+```
+
+✓ Workspace initialization started
+
+Workspace: /path/to/your/project
+Detected Languages: ["python", "rust", "typescript"]
+Project Markers: ["Cargo.toml", "package.json"]
+
+Available LSPs:
+○ clangd (cpp) - available
+○ gopls (go) - not installed
+◐ jdtls (java) - initializing...
+✓ jedi-language-server (python) - initialized (687ms)
+✓ rust-analyzer (rust) - initialized (488ms)
+○ solargraph (ruby) - not installed
+✓ typescript-language-server (typescript) - initialized (214ms)
+
+
+```
+
+**Status indicators:**
+  * ✓ - Initialized and ready
+  * ◐ - Currently initializing
+  * ○ available - Installed but not needed for detected languages
+  * ○ not installed - Not installed on your system
+
+
+**Restart LSP servers:** If language servers shut down or become unresponsive, use `/code init -f`.
+**Auto-initialization:** After the first `/code init`, Kiro CLI automatically initializes code intelligence on startup when `.kiro/settings/lsp.json` exists in the workspace.
+**Disabling code intelligence:** Delete `.kiro/settings/lsp.json` from your project to disable. You must restart your session for this change to take effect. Re-enable anytime with `/code init`.
+## Using Language Servers[](https://kiro.dev/docs/cli/code-intelligence/#using-language-servers)
+Language servers provide semantic code intelligence through natural language queries. You can search symbols, navigate definitions, find references, rename across files, get diagnostics, view method documentation, and discover available APIs on classes and objects.
+### Example 1: Find a Symbol[](https://kiro.dev/docs/cli/code-intelligence/#example-1-find-a-symbol)
+```
+
+> Find the UserRepository class
+
+Searching for symbols matching: "UserRepository"
+
+  1. Class UserRepository at src/repositories/user.repository.ts:15:1
+
+
+```
+
+### Example 2: Find All References[](https://kiro.dev/docs/cli/code-intelligence/#example-2-find-all-references)
+```
+
+> Find references of Person class
+
+Finding all references at: auth.ts:42:10
+
+  1. src/auth.ts:42:10 - export function authenticate(...)
+  2. src/handlers/login.ts:15:5 - authenticate(credentials)
+  3. src/handlers/api.ts:89:12 - await authenticate(token)
+  (3 more items found)
+
+
+```
+
+### Example 3: Go to Definition[](https://kiro.dev/docs/cli/code-intelligence/#example-3-go-to-definition)
+```
+
+> Find the definition of UserService
+
+src/services/user.service.ts:42:1: export class UserService { ...
+
+
+```
+
+### Example 4: Get File Symbols[](https://kiro.dev/docs/cli/code-intelligence/#example-4-get-file-symbols)
+```
+
+> What symbols are in auth.service.ts?
+
+Getting symbols from: auth.service.ts
+
+  1. Class AuthService at auth.service.ts:12:1
+  2. Function login at auth.service.ts:25:3
+  3. Function logout at auth.service.ts:45:3
+  4. Function validateToken at auth.service.ts:62:3
+
+
+```
+
+### Example 5: Rename with Dry Run[](https://kiro.dev/docs/cli/code-intelligence/#example-5-rename-with-dry-run)
+```
+
+> Dry run: rename the method "FetchUser" to "fetchUserData"
+
+Dry run: Would rename 12 occurrences in 5 files
+
+
+```
+
+### Example 6: Get Diagnostics[](https://kiro.dev/docs/cli/code-intelligence/#example-6-get-diagnostics)
+```
+
+> Get diagnostics for main.ts
+
+  1. Error line 15:10: Cannot find name 'undefined_var'
+  2. Warning line 42:5: 'result' is declared but never used
+
+
+```
+
+### Example 7: Get Hover Information[](https://kiro.dev/docs/cli/code-intelligence/#example-7-get-hover-information)
+```
+
+> What's the documentation for the authenticate method in AuthService?
+
+Type: (credentials: Credentials) => Promise<AuthResult>
+
+Documentation: Authenticates a user with the provided credentials.
+Returns an AuthResult containing the user token and profile.
+
+@param credentials - User login credentials
+@throws AuthenticationError if credentials are invalid
+
+
+```
+
+### Example 8: Get Code Completions[](https://kiro.dev/docs/cli/code-intelligence/#example-8-get-code-completions)
+```
+
+> What methods are available on the s3Client instance?
+
+Available completions:
+
+  1. putObject - Function: (params: PutObjectRequest) => Promise<PutObjectOutput>
+  2. getObject - Function: (params: GetObjectRequest) => Promise<GetObjectOutput>
+  3. deleteObject - Function: (params: DeleteObjectRequest) => Promise<DeleteObjectOutput>
+  4. listObjects - Function: (params: ListObjectsRequest) => Promise<ListObjectsOutput>
+  5. headObject - Function: (params: HeadObjectRequest) => Promise<HeadObjectOutput>
+
+
+```
+
+## Custom Language Servers[](https://kiro.dev/docs/cli/code-intelligence/#custom-language-servers)
+Add custom language servers by editing `.kiro/settings/lsp.json` in your project:
+json
+```
+
+{ 
+  "languages": { 
+    "mylang": { 
+      "name": "my-language-server", 
+      "command": "my-lsp-binary", 
+      "args": ["--stdio"], 
+      "file_extensions": ["mylang", "ml"], 
+      "project_patterns": ["mylang.config"], 
+      "exclude_patterns": ["**/build/**"], 
+      "multi_workspace": false, 
+      "initialization_options": { "custom": "options" } 
+    } 
+  } 
+}
+
+
+```
+
+**Fields:**
+  * **name** : Display name for the language server
+  * **command** : Binary/command to execute
+  * **args** : Command line arguments (usually ["--stdio"])
+  * **file_extensions** : File extensions this server handles
+  * **project_patterns** : Files that indicate a project root (e.g., package.json)
+  * **exclude_patterns** : Glob patterns to exclude from analysis
+  * **multi_workspace** : Set to true if the LSP supports multiple workspace folders (default: false)
+  * **initialization_options** : LSP-specific configuration passed during initialization
+  * **request_timeout_secs** : Timeout in seconds for LSP requests. Default is 60.
+
+
+After editing, restart KIRO CLI to load the new configuration.
+## Troubleshooting[](https://kiro.dev/docs/cli/code-intelligence/#troubleshooting)
+Issue | Cause(s) | Solution  
+---|---|---  
+Workspace is still initializing | LSP servers are starting up | Wait and try again. If servers crashed, use `/code init -f` to restart.  
+LSP initialization failed |  | Check logs for details: `/code logs -l`  
+No symbols found | Language server is still indexing or File has syntax errors or Symbol name doesn't match | Check file for errors, try broader search terms.  
+No definition found | Position doesn't point to a symbol. Solution: Verify the row and column numbers point to a symbol name. |   
+## Best Practices[](https://kiro.dev/docs/cli/code-intelligence/#best-practices)
+  1. Initialize once per project - Run `/code init` in project root
+  2. Use exact positions - Row and column must point to the symbol
+  3. Use dry_run for renames - Preview changes before applying
+  4. Check diagnostics first - Syntax errors can prevent analysis
+  5. Be specific in searches - "UserService" > "user"
+  6. Ask for documentation naturally - "What does the login method do?" instead of specifying coordinates
+  7. Discover APIs conversationally - "What methods does s3Client have?" to explore external library functionality
+
+
+## Limitations[](https://kiro.dev/docs/cli/code-intelligence/#limitations)
+  1. LSP feature support varies by language server - not all servers support every operation (e.g., some may not support rename or formatting)
+  2. Large codebases may have slow initial indexing
+
+
+Page updated: December 18, 2025
+[Auto complete](https://kiro.dev/docs/cli/autocomplete/)
+[Billing for individuals](https://kiro.dev/docs/cli/billing/)
+On this page
+  * [Overview](https://kiro.dev/docs/cli/code-intelligence/#overview)
+  * [How it works](https://kiro.dev/docs/cli/code-intelligence/#how-it-works)
+  * [Installing language servers](https://kiro.dev/docs/cli/code-intelligence/#installing-language-servers)
+  * [Initialize Code Intelligence](https://kiro.dev/docs/cli/code-intelligence/#initialize-code-intelligence)
+  * [Using Language Servers](https://kiro.dev/docs/cli/code-intelligence/#using-language-servers)
+  * [Example 1: Find a Symbol](https://kiro.dev/docs/cli/code-intelligence/#example-1-find-a-symbol)
+  * [Example 2: Find All References](https://kiro.dev/docs/cli/code-intelligence/#example-2-find-all-references)
+  * [Example 3: Go to Definition](https://kiro.dev/docs/cli/code-intelligence/#example-3-go-to-definition)
+  * [Example 4: Get File Symbols](https://kiro.dev/docs/cli/code-intelligence/#example-4-get-file-symbols)
+  * [Example 5: Rename with Dry Run](https://kiro.dev/docs/cli/code-intelligence/#example-5-rename-with-dry-run)
+  * [Example 6: Get Diagnostics](https://kiro.dev/docs/cli/code-intelligence/#example-6-get-diagnostics)
+  * [Example 7: Get Hover Information](https://kiro.dev/docs/cli/code-intelligence/#example-7-get-hover-information)
+  * [Example 8: Get Code Completions](https://kiro.dev/docs/cli/code-intelligence/#example-8-get-code-completions)
+  * [Custom Language Servers](https://kiro.dev/docs/cli/code-intelligence/#custom-language-servers)
+  * [Troubleshooting](https://kiro.dev/docs/cli/code-intelligence/#troubleshooting)
+  * [Best Practices](https://kiro.dev/docs/cli/code-intelligence/#best-practices)
+  * [Limitations](https://kiro.dev/docs/cli/code-intelligence/#limitations)

package/.kiro/documentation/docs_cli_custom-agents.md

@@ -0,0 +1,37 @@
+# Custom agents
+Custom agents provide a way to customize Kiro behavior by defining specific configurations for different use cases. Each custom agent is defined by a configuration file that specifies which tools the agent can access, what permissions it has, and what context it should include.
+By default, Kiro CLI provides access to all available tools but requires user confirmation for most operations. This approach prioritizes security but can interrupt your workflow with frequent permission prompts.
+Custom agents solve this by allowing you to:
+  * **Pre-approve specific tools** - Define which tools can run without prompting
+  * **Limit tool access** - Restrict which tools are available to reduce complexity
+  * **Include relevant context** - Automatically load project files, documentation, or system information
+  * **Configure tool behavior** - Set specific parameters for how tools should operate
+
+
+### Benefits of using custom agents[](https://kiro.dev/docs/cli/custom-agents/#benefits-of-using-custom-agents)
+  1. Workflow optimization - Create custom agents tailored to specific tasks like AWS infrastructure management, code reviews, or debugging sessions.
+  2. Reduced interruptions - Pre-approve trusted tools to eliminate permission prompts during focused work sessions.
+  3. Enhanced context - Automatically include relevant project documentation, configuration files, or system information.
+  4. Team collaboration - Share custom agent configurations with team members to ensure consistent development environments.
+  5. Security control - Limit tool access to only what's needed for specific workflows, reducing potential security risks.
+
+
+### Relationship to MCP and built-in tools[](https://kiro.dev/docs/cli/custom-agents/#relationship-to-mcp-and-built-in-tools)
+Custom agents work with both built-in tools and external tools provided through the Model Context Protocol (MCP). This gives you flexibility to:
+  * Use built-in tools - File operations, command execution, AWS CLI integration, and other core functionality
+  * Integrate MCP servers - Add custom tools and services through MCP server configurations
+  * Control tool access - Specify exactly which tools from each source are available
+  * Manage tool conflicts - Use aliases to handle naming conflicts between different tool sources
+
+
+## Next steps[](https://kiro.dev/docs/cli/custom-agents/#next-steps)
+  * Learn how to [Create Custom Agents](https://kiro.dev/docs/cli/custom-agents/creating)
+
+
+Page updated: November 18, 2025
+[Configuration](https://kiro.dev/docs/cli/chat/configuration/)
+[Creating custom agents](https://kiro.dev/docs/cli/custom-agents/creating/)
+On this page
+  * [Benefits of using custom agents](https://kiro.dev/docs/cli/custom-agents/#benefits-of-using-custom-agents)
+  * [Relationship to MCP and built-in tools](https://kiro.dev/docs/cli/custom-agents/#relationship-to-mcp-and-built-in-tools)
+  * [Next steps](https://kiro.dev/docs/cli/custom-agents/#next-steps)