Put in a recent project picker

server/src/http/anthropic.rs

@@ -1,9 +1,42 @@
 use crate::http::context::{AppContext, OpenApiResult, bad_request};
 use crate::llm::chat;
+use crate::store::StoreOps;
 use poem_openapi::{Object, OpenApi, Tags, payload::Json};
+use reqwest::header::{HeaderMap, HeaderValue};
 use serde::Deserialize;
 use std::sync::Arc;
 
+const ANTHROPIC_MODELS_URL: &str = "https://api.anthropic.com/v1/models";
+const ANTHROPIC_VERSION: &str = "2023-06-01";
+const KEY_ANTHROPIC_API_KEY: &str = "anthropic_api_key";
+
+#[derive(Deserialize)]
+struct AnthropicModelsResponse {
+    data: Vec<AnthropicModelInfo>,
+}
+
+#[derive(Deserialize)]
+struct AnthropicModelInfo {
+    id: String,
+}
+
+fn get_anthropic_api_key(ctx: &AppContext) -> Result<String, String> {
+    match ctx.store.get(KEY_ANTHROPIC_API_KEY) {
+        Some(value) => {
+            if let Some(key) = value.as_str() {
+                if key.is_empty() {
+                    Err("Anthropic API key is empty. Please set your API key.".to_string())
+                } else {
+                    Ok(key.to_string())
+                }
+            } else {
+                Err("Stored API key is not a string".to_string())
+            }
+        }
+        None => Err("Anthropic API key not found. Please set your API key.".to_string()),
+    }
+}
+
 #[derive(Deserialize, Object)]
 struct ApiKeyPayload {
     api_key: String,
@@ -48,4 +81,46 @@ impl AnthropicApi {
             .map_err(bad_request)?;
         Ok(Json(true))
     }
+
+    /// List available Anthropic models.
+    #[oai(path = "/anthropic/models", method = "get")]
+    async fn list_anthropic_models(&self) -> OpenApiResult<Json<Vec<String>>> {
+        let api_key = get_anthropic_api_key(self.ctx.as_ref()).map_err(bad_request)?;
+        let client = reqwest::Client::new();
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            "x-api-key",
+            HeaderValue::from_str(&api_key).map_err(|e| bad_request(e.to_string()))?,
+        );
+        headers.insert(
+            "anthropic-version",
+            HeaderValue::from_static(ANTHROPIC_VERSION),
+        );
+
+        let response = client
+            .get(ANTHROPIC_MODELS_URL)
+            .headers(headers)
+            .send()
+            .await
+            .map_err(|e| bad_request(e.to_string()))?;
+
+        if !response.status().is_success() {
+            let status = response.status();
+            let error_text = response
+                .text()
+                .await
+                .unwrap_or_else(|_| "Unknown error".to_string());
+            return Err(bad_request(format!(
+                "Anthropic API error {status}: {error_text}"
+            )));
+        }
+
+        let body = response
+            .json::<AnthropicModelsResponse>()
+            .await
+            .map_err(|e| bad_request(e.to_string()))?;
+        let models = body.data.into_iter().map(|m| m.id).collect();
+
+        Ok(Json(models))
+    }
 }

server/src/http/project.rs

@@ -47,4 +47,11 @@ impl ProjectApi {
         fs::close_project(&self.ctx.state, self.ctx.store.as_ref()).map_err(bad_request)?;
         Ok(Json(true))
     }
+
+    /// List known projects from the store.
+    #[oai(path = "/projects", method = "get")]
+    async fn list_known_projects(&self) -> OpenApiResult<Json<Vec<String>>> {
+        let projects = fs::get_known_projects(self.ctx.store.as_ref()).map_err(bad_request)?;
+        Ok(Json(projects))
+    }
 }

server/src/http/ws.rs

@@ -6,6 +6,7 @@ use poem::handler;
 use poem::web::Data;
 use poem::web::websocket::{Message as WsMessage, WebSocket};
 use serde::{Deserialize, Serialize};
+use std::sync::Arc;
 use tokio::sync::mpsc;
 
 #[derive(Deserialize)]
@@ -39,7 +40,7 @@ enum WsResponse {
 /// WebSocket endpoint for streaming chat responses and cancellation.
 ///
 /// Accepts JSON `WsRequest` messages and streams `WsResponse` messages.
-pub async fn ws_handler(ws: WebSocket, ctx: Data<&AppContext>) -> impl poem::IntoResponse {
+pub async fn ws_handler(ws: WebSocket, ctx: Data<&Arc<AppContext>>) -> impl poem::IntoResponse {
     let ctx = ctx.0.clone();
     ws.on_upgrade(move |socket| async move {
         let (mut sink, mut stream) = socket.split();

server/src/io/fs.rs

@@ -7,6 +7,7 @@ use std::path::PathBuf;
 
 const KEY_LAST_PROJECT: &str = "last_project_path";
 const KEY_SELECTED_MODEL: &str = "selected_model";
+const KEY_KNOWN_PROJECTS: &str = "known_projects";
 
 /// Resolves a relative path against the active project root (pure function for testing).
 /// Returns error if path attempts traversal (..).
@@ -55,6 +56,13 @@ pub async fn open_project(
     }
 
     store.set(KEY_LAST_PROJECT, json!(path));
+
+    let mut known_projects = get_known_projects(store)?;
+
+    known_projects.retain(|p| p != &path);
+    known_projects.insert(0, path.clone());
+    store.set(KEY_KNOWN_PROJECTS, json!(known_projects));
+
     store.save()?;
 
     Ok(path)
@@ -99,6 +107,18 @@ pub fn get_current_project(
     Ok(None)
 }
 
+pub fn get_known_projects(store: &dyn StoreOps) -> Result<Vec<String>, String> {
+    let projects = store
+        .get(KEY_KNOWN_PROJECTS)
+        .and_then(|val| val.as_array().cloned())
+        .unwrap_or_default()
+        .into_iter()
+        .filter_map(|val| val.as_str().map(|s| s.to_string()))
+        .collect();
+
+    Ok(projects)
+}
+
 pub fn get_model_preference(store: &dyn StoreOps) -> Result<Option<String>, String> {
     if let Some(model) = store
         .get(KEY_SELECTED_MODEL)