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 the lsp.json file 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

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

Supported Languages

Initialize Code Intelligence

Run this slash command in your project root:

/code init

This creates 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 lsp.json exists in the workspace.

Disabling code intelligence: Delete lsp.json from your project root to disable. Re-enable anytime with /code init.

Using Language Servers

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

> 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

> Find the definition of UserService

src/services/user.service.ts:42:1: export class UserService { ...

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

> Dry run: rename the method "FetchUser" to "fetchUserData"

Dry run: Would rename 12 occurrences in 5 files

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

Custom Language Servers

Add custom language servers by editing lsp.json in your project root:

{ 
  "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

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"

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