[dependencies]
cersei-lsp = "0.1.6"

LspManager (multi-server registry)
├── LspClient (rust-analyzer) ── JSON-RPC ── rust-analyzer process
├── LspClient (pyright) ── JSON-RPC ── pyright-langserver process
└── LspClient (gopls) ── JSON-RPC ── gopls process

use cersei_lsp::{LspManager, LspServerConfig};
use std::path::Path;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut mgr = LspManager::new("/path/to/project");
    mgr.register_builtins(); // Register 13 built-in servers

    // Hover: get type info at a position
    let hover = mgr.hover(Path::new("src/main.rs"), 10, 5).await?;
    println!("Hover: {:?}", hover);

    // Go-to-definition
    let defs = mgr.definition(Path::new("src/lib.rs"), 25, 12).await?;
    for loc in &defs {
        println!("Defined at: {loc}");
    }

    // Find all references
    let refs = mgr.references(Path::new("src/lib.rs"), 25, 12).await?;
    println!("Found {} references", refs.len());

    // Document symbols (file outline)
    let symbols = mgr.document_symbols(Path::new("src/lib.rs")).await?;
    for sym in &symbols {
        print!("{}", sym.format(0)); // Indented tree output
    }

    // Diagnostics (compiler errors/warnings)
    let diags = mgr.diagnostics(Path::new("src/main.rs")).await?;
    println!("{}", LspManager::format_diagnostics(&diags));

    mgr.shutdown_all().await;
    Ok(())
}

use cersei_lsp::{LspClient, LspServerConfig};

let config = LspServerConfig::new(
    "rust-analyzer", "rust-analyzer",
    &["*.rs"], &[(".rs", "rust")]
);
let client = LspClient::new(config);
client.start(Path::new("/project")).await?;
client.initialize().await?;
client.open_document(Path::new("/project/src/main.rs")).await?;

let hover = client.hover(Path::new("/project/src/main.rs"), 10, 5).await?;
client.shutdown().await?;

// Symbol from document_symbols()
pub struct SymbolInfo {
    pub name: String,      // e.g. "Config"
    pub kind: String,      // e.g. "struct", "function", "class"
    pub range: Range,      // Start/end position
    pub children: Vec<SymbolInfo>, // Nested symbols (methods, fields)
}

// Diagnostic from diagnostics()
pub struct LspDiagnostic {
    pub file: String,
    pub line: u32,          // 0-based
    pub col: u32,           // 0-based
    pub severity: DiagnosticSeverity, // Error, Warning, Information, Hint
    pub message: String,
    pub source: Option<String>,  // e.g. "rustc", "clippy"
    pub code: Option<String>,    // e.g. "E0308"
}

use cersei_lsp::{LspManager, LspServerConfig};

let mut mgr = LspManager::new("/project");

// Add Elixir support
let mut elixir = LspServerConfig::new(
    "elixir-ls", "elixir-ls",
    &["*.ex", "*.exs"],
    &[(".ex", "elixir"), (".exs", "elixir")],
);
elixir.args = vec!["--stdio".to_string()];
mgr.register_server(elixir);

mgr.register_builtins(); // Also load defaults

use cersei_lsp::global_lsp_manager;

let mgr = global_lsp_manager(Path::new("/project"));
let mut guard = mgr.lock().await;
guard.register_builtins();
let symbols = guard.document_symbols(Path::new("src/lib.rs")).await?;

use cersei_tools::tool_primitives::code_intel::{analyze_file, Language};
use std::path::Path;

let source = r#"
use std::collections::HashMap;
use serde::Serialize;

pub struct Config {
    pub name: String,
}

pub fn load_config() -> Config {
    Config { name: "test".into() }
}
"#;

let intel = analyze_file(Path::new("config.rs"), source).unwrap();
assert_eq!(intel.language, Language::Rust);
assert_eq!(intel.imports.len(), 2);       // HashMap, Serialize
assert!(intel.symbols.iter().any(|s| s.name == "Config"));
assert!(intel.symbols.iter().any(|s| s.name == "load_config"));

for sym in &intel.symbols {
    println!("  {} {} (line {})", sym.kind.label(), sym.name, sym.line);
}
// Output:
//   struct Config (line 5)
//   fn load_config (line 9)

use cersei_tools::tool_primitives::code_intel::{scan_project, format_project_intel};
use std::path::Path;

let intels = scan_project(Path::new("/path/to/project"), 20);

// Print ranked file summaries
println!("{}", format_project_intel(&intels));
// Output:
// - src/main.rs — fn main | imports: use crate::config, use std::sync::Arc
// - src/config.rs — struct Config, fn load_config | imports: use serde::Serialize
// - src/lib.rs — mod config, mod server, mod routes

use cersei_tools::tool_primitives::bash_safety::{analyze_command, is_safe, is_forbidden};

// Safe commands
assert!(is_safe("ls -la"));
assert!(is_safe("grep -r 'TODO' src/"));
assert!(is_safe("git status"));

// Dangerous commands
assert!(is_forbidden("sudo rm -rf /"));
assert!(is_forbidden("dd if=/dev/zero of=/dev/sda"));

// Detailed analysis
let analysis = analyze_command("git push origin main && rm temp.txt");
println!("Risk: {:?}", analysis.risk);        // High
println!("Reasons: {:?}", analysis.reasons);   // ["git push", "file deletion (rm)"]
println!("Commands: {:?}", analysis.commands);  // ["git", "rm"]
println!("Write paths: {:?}", analysis.write_paths); // ["temp.txt"]

{
  "action": "hover | definition | references | symbols | diagnostics",
  "file": "/path/to/file.rs",
  "line": 10,
  "column": 5
}

User: What type is the `config` variable on line 15 of src/main.rs?

Agent: [calls LSP tool with action=hover, file=src/main.rs, line=15, column=10]
       The `config` variable is of type `AppConfig` (defined in src/config.rs:17).