#![deny(unsafe_code)]
use std::{io::stdout, sync::Arc, time::Duration};
use anyhow::{Context as _, Result};
use clap::Parser;
use crossterm::{
event::{DisableBracketedPaste, EnableBracketedPaste, Event as TerminalEvent, EventStream},
execute,
};
use nachalnik::{Config, ContextItem, Event, Kernel, LinearProjector};
use ratatui::DefaultTerminal;
use tokio::sync::{broadcast::error::RecvError, mpsc};
use tokio_stream::StreamExt;
use kamchatka::{
app::{App, Outcome, Speaker},
gemini, introspect,
provider::{self, Endpoint},
sandbox, tools, ui,
};
const TICK: Duration = Duration::from_millis(120);
#[derive(Parser)]
#[command(
version,
about,
long_about = None,
after_help = "\
Environment:
KAMCHATKA_API_KEY the key; or OPENROUTER_API_KEY, or OPENAI_API_KEY
KAMCHATKA_BASE_URL where the requests go, e.g. http://localhost:11434/v1 for ollama;
OpenRouter by default, or Google's own v1beta with --gemini
KAMCHATKA_CONTEXT_LIMIT the model's context size, for a provider that will not say"
)]
struct Args {
message: Vec<String>,
#[arg(short, long, env = "KAMCHATKA_MODEL")]
model: Option<String>,
#[arg(long)]
gemini: bool,
#[arg(short, long, value_name = "PATH")]
file: Vec<String>,
#[arg(short, long, value_name = "TEXT")]
system: Option<String>,
#[arg(short, long, value_name = "PATH")]
resume: Option<String>,
#[cfg(feature = "mcp")]
#[arg(long, value_name = "COMMAND")]
mcp: Vec<String>,
#[arg(long, value_name = "N", default_value_t = 8)]
requests: usize,
#[arg(long, value_name = "FRACTION", default_value_t = 0.8)]
compact: f64,
#[arg(long)]
parallel: bool,
#[arg(long)]
no_sandbox: bool,
#[arg(long)]
introspect: bool,
#[arg(long, value_name = "PATH")]
sandbox_allow: Vec<std::path::PathBuf>,
}
fn main() -> Result<()> {
if let Some(code) = sandbox::run_if_asked() {
std::process::exit(code);
}
tokio::runtime::Builder::new_multi_thread()
.enable_all()
.build()?
.block_on(terminal())
}
async fn terminal() -> Result<()> {
let args = Args::parse();
let model = args.model.clone().unwrap_or_else(|| {
match args.gemini {
true => "gemini-3.6-flash",
false => "openai/gpt-4o-mini",
}
.to_owned()
});
let provider: Arc<dyn Endpoint> = match args.gemini {
true => gemini::connect(&model)
.await
.map(|it| it as Arc<dyn Endpoint>),
false => provider::connect(&model)
.await
.map(|it| it as Arc<dyn Endpoint>),
}
.map_err(|e| anyhow::anyhow!("{e}"))
.context("could not reach the model")?;
let config = Config {
max_requests_per_turn: (args.requests > 0).then_some(args.requests),
parallel_tool_calls: args.parallel,
..Default::default()
};
let kernel = match &args.resume {
Some(path) => {
let snapshot = serde_json::from_slice(
&std::fs::read(path).with_context(|| format!("could not read {path}"))?,
)
.with_context(|| format!("{path} is not a session"))?;
Kernel::resume(config, snapshot)
}
None => Kernel::new(config),
};
let mut events = kernel.subscribe();
let policy = Arc::new(tools::Careful::new());
kernel.set_provider(provider.clone());
kernel.set_policy(policy.clone());
if args.gemini {
kernel.set_projector(Arc::new(LinearProjector {
send_blocks: true,
..Default::default()
}));
}
if args.compact < 1.0 {
kernel.set_compactor(Some(Arc::new(tools::Trim {
threshold: args.compact,
target: (args.compact - 0.2).max(0.1),
})));
}
let program = std::env::current_exe()?;
let confinement = match args.no_sandbox {
true => sandbox::Confinement::Unsupported,
false => sandbox::available(&program),
};
let reach = sandbox::Reach {
workdir: std::env::current_dir()?,
extra: args.sandbox_allow.clone(),
confined: !args.no_sandbox,
};
for tool in tools::builtin(
tools::Shell {
policy: policy.clone(),
workdir: reach.workdir.clone(),
extra: reach.extra.clone(),
confiner: confinement.is_confined().then(|| program.clone()),
},
reach,
) {
kernel.add_tool(tool);
}
let introspect = args.introspect.then(|| introspect::install(&kernel));
#[cfg(feature = "mcp")]
let _servers = attach_mcp(&kernel, &args.mcp).await?;
if let Some(system) = &args.system {
kernel.push(ContextItem::system(system.clone()).pinned());
}
for path in &args.file {
let content =
std::fs::read_to_string(path).with_context(|| format!("could not read {path}"))?;
kernel.push(
ContextItem::file(path, content)
.because("named on the command line")
.pinned(),
);
}
let (outcomes, mut finished) = mpsc::unbounded_channel();
let mut app = App::new(kernel, policy, provider, outcomes);
app.confinement = confinement;
app.introspect = introspect;
match args.resume.is_some() {
true => app.replay(),
false => app.say(
Speaker::Note,
"tab moves to the context · ctrl+t swaps it for the trace · ctrl+p shows the \
next request · F1 lists the keys",
),
}
if let Some(message) = (!args.message.is_empty()).then(|| args.message.join(" ")) {
app.say(Speaker::User, &message);
app.kernel.push(ContextItem::user(message));
app.start_turn();
}
let previous = std::panic::take_hook();
std::panic::set_hook(Box::new(move |info| {
let _ = execute!(stdout(), DisableBracketedPaste);
previous(info);
}));
let mut terminal = ratatui::init();
let _ = execute!(stdout(), EnableBracketedPaste);
let outcome = run(&mut terminal, &mut app, &mut events, &mut finished).await;
let _ = execute!(stdout(), DisableBracketedPaste);
ratatui::restore();
app.kernel.finish();
println!(
"{} · {} events recorded",
app.kernel.session_name(),
app.kernel.history().len()
);
outcome
}
async fn run(
terminal: &mut DefaultTerminal,
app: &mut App,
events: &mut tokio::sync::broadcast::Receiver<Event>,
finished: &mut mpsc::UnboundedReceiver<Outcome>,
) -> Result<()> {
let mut keys = EventStream::new();
let mut ticks = tokio::time::interval(TICK);
loop {
terminal.draw(|frame| ui::draw(frame, app))?;
if app.quit {
return Ok(());
}
tokio::select! {
key = keys.next() => match key {
Some(Ok(TerminalEvent::Key(key))) => app.on_key(key).await,
Some(Ok(TerminalEvent::Paste(text))) => app.paste(&text),
Some(Ok(_)) => {}
Some(Err(e)) => return Err(e).context("the terminal stopped talking"),
None => return Ok(()),
},
event = events.recv() => match event {
Ok(event) => app.on_event(event),
Err(RecvError::Lagged(missed)) => app.say(
Speaker::Note,
format!("{missed} events went by too fast to draw; /save has them all"),
),
Err(RecvError::Closed) => return Ok(()),
},
Some(outcome) = finished.recv() => {
while let Ok(event) = events.try_recv() {
app.on_event(event);
}
app.on_outcome(outcome);
}
_ = ticks.tick() => {
if let Some(notice) = app.provider.take_notice() {
app.say(Speaker::Note, notice);
}
}
}
}
}
#[cfg(feature = "mcp")]
async fn attach_mcp(kernel: &Kernel, commands: &[String]) -> Result<Vec<nachalnik_mcp::Server>> {
let mut servers = Vec::new();
for spec in commands {
let (name, line) = match spec.split_once('=') {
Some((name, rest))
if !name.is_empty()
&& !name.contains(char::is_whitespace)
&& !name.contains('/') =>
{
(name.to_owned(), rest.trim())
}
_ => (String::new(), spec.as_str()),
};
let mut words = line.split_whitespace();
let program = words.next().context("--mcp needs a command to run")?;
let name = match name.is_empty() {
false => name,
true => std::path::Path::new(program)
.file_stem()
.and_then(|stem| stem.to_str())
.unwrap_or(program)
.to_owned(),
};
let mut command = tokio::process::Command::new(program);
command.args(words);
let server = nachalnik_mcp::Server::spawn(name, command)
.await
.with_context(|| format!("`{line}` did not answer the handshake"))?;
server
.install(kernel)
.await
.with_context(|| format!("`{line}` would not list its tools"))?;
servers.push(server);
}
Ok(servers)
}