Restore codebase deleted by bad auto-commit e4227cf

Commit e4227cf (a story creation auto-commit) erroneously deleted 175 files from master's tree, likely due to a race condition between concurrent git operations. This commit re-adds all files from the working directory. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
2026-03-22 19:07:07 +00:00
parent 89f776b978
commit f610ef6046
174 changed files with 84280 additions and 0 deletions
@@ -0,0 +1,369 @@
+use crate::http::context::{AppContext, OpenApiResult, bad_request};
+use crate::store::StoreOps;
+use poem_openapi::{Object, OpenApi, Tags, param::Query, payload::Json};
+use serde::Serialize;
+use serde_json::json;
+use std::sync::Arc;
+
+const EDITOR_COMMAND_KEY: &str = "editor_command";
+
+#[derive(Tags)]
+enum SettingsTags {
+    Settings,
+}
+
+#[derive(Object)]
+struct EditorCommandPayload {
+    editor_command: Option<String>,
+}
+
+#[derive(Object, Serialize)]
+struct EditorCommandResponse {
+    editor_command: Option<String>,
+}
+
+#[derive(Debug, Object, Serialize)]
+struct OpenFileResponse {
+    success: bool,
+}
+
+pub struct SettingsApi {
+    pub ctx: Arc<AppContext>,
+}
+
+#[OpenApi(tag = "SettingsTags::Settings")]
+impl SettingsApi {
+    /// Get the configured editor command (e.g. "zed", "code", "cursor"), or null if not set.
+    #[oai(path = "/settings/editor", method = "get")]
+    async fn get_editor(&self) -> OpenApiResult<Json<EditorCommandResponse>> {
+        let editor_command = self
+            .ctx
+            .store
+            .get(EDITOR_COMMAND_KEY)
+            .and_then(|v| v.as_str().map(|s| s.to_string()));
+        Ok(Json(EditorCommandResponse { editor_command }))
+    }
+
+    /// Open a file in the configured editor at the given line number.
+    ///
+    /// Invokes the stored editor CLI (e.g. "zed", "code") with `path:line` as the argument.
+    /// Returns an error if no editor is configured or if the process fails to spawn.
+    #[oai(path = "/settings/open-file", method = "post")]
+    async fn open_file(
+        &self,
+        path: Query<String>,
+        line: Query<Option<u32>>,
+    ) -> OpenApiResult<Json<OpenFileResponse>> {
+        let editor_command = get_editor_command_from_store(&self.ctx)
+            .ok_or_else(|| bad_request("No editor configured".to_string()))?;
+
+        let file_ref = match line.0 {
+            Some(l) => format!("{}:{}", path.0, l),
+            None => path.0.clone(),
+        };
+
+        std::process::Command::new(&editor_command)
+            .arg(&file_ref)
+            .spawn()
+            .map_err(|e| bad_request(format!("Failed to open editor: {e}")))?;
+
+        Ok(Json(OpenFileResponse { success: true }))
+    }
+
+    /// Set the preferred editor command (e.g. "zed", "code", "cursor").
+    /// Pass null or empty string to clear the preference.
+    #[oai(path = "/settings/editor", method = "put")]
+    async fn set_editor(
+        &self,
+        payload: Json<EditorCommandPayload>,
+    ) -> OpenApiResult<Json<EditorCommandResponse>> {
+        let editor_command = payload.0.editor_command;
+        let trimmed = editor_command.as_deref().map(str::trim).filter(|s| !s.is_empty());
+        match trimmed {
+            Some(cmd) => {
+                self.ctx.store.set(EDITOR_COMMAND_KEY, json!(cmd));
+                self.ctx.store.save().map_err(bad_request)?;
+                Ok(Json(EditorCommandResponse {
+                    editor_command: Some(cmd.to_string()),
+                }))
+            }
+            None => {
+                self.ctx.store.delete(EDITOR_COMMAND_KEY);
+                self.ctx.store.save().map_err(bad_request)?;
+                Ok(Json(EditorCommandResponse {
+                    editor_command: None,
+                }))
+            }
+        }
+    }
+}
+
+pub fn get_editor_command_from_store(ctx: &AppContext) -> Option<String> {
+    ctx.store
+        .get(EDITOR_COMMAND_KEY)
+        .and_then(|v| v.as_str().map(|s| s.to_string()))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::http::context::AppContext;
+    use std::sync::Arc;
+    use tempfile::TempDir;
+
+    fn test_ctx(dir: &TempDir) -> AppContext {
+        AppContext::new_test(dir.path().to_path_buf())
+    }
+
+    fn make_api(dir: &TempDir) -> SettingsApi {
+        SettingsApi {
+            ctx: Arc::new(AppContext::new_test(dir.path().to_path_buf())),
+        }
+    }
+
+    #[tokio::test]
+    async fn get_editor_returns_none_when_unset() {
+        let dir = TempDir::new().unwrap();
+        let api = make_api(&dir);
+        let result = api.get_editor().await.unwrap();
+        assert!(result.0.editor_command.is_none());
+    }
+
+    #[tokio::test]
+    async fn set_editor_stores_command() {
+        let dir = TempDir::new().unwrap();
+        let api = make_api(&dir);
+        let payload = Json(EditorCommandPayload {
+            editor_command: Some("zed".to_string()),
+        });
+        let result = api.set_editor(payload).await.unwrap();
+        assert_eq!(result.0.editor_command, Some("zed".to_string()));
+    }
+
+    #[tokio::test]
+    async fn set_editor_clears_command_on_null() {
+        let dir = TempDir::new().unwrap();
+        let api = make_api(&dir);
+        api.set_editor(Json(EditorCommandPayload {
+            editor_command: Some("zed".to_string()),
+        }))
+        .await
+        .unwrap();
+        let result = api
+            .set_editor(Json(EditorCommandPayload {
+                editor_command: None,
+            }))
+            .await
+            .unwrap();
+        assert!(result.0.editor_command.is_none());
+    }
+
+    #[tokio::test]
+    async fn set_editor_clears_command_on_empty_string() {
+        let dir = TempDir::new().unwrap();
+        let api = make_api(&dir);
+        let result = api
+            .set_editor(Json(EditorCommandPayload {
+                editor_command: Some(String::new()),
+            }))
+            .await
+            .unwrap();
+        assert!(result.0.editor_command.is_none());
+    }
+
+    #[tokio::test]
+    async fn set_editor_trims_whitespace_only() {
+        let dir = TempDir::new().unwrap();
+        let api = make_api(&dir);
+        let result = api
+            .set_editor(Json(EditorCommandPayload {
+                editor_command: Some("   ".to_string()),
+            }))
+            .await
+            .unwrap();
+        assert!(result.0.editor_command.is_none());
+    }
+
+    #[tokio::test]
+    async fn get_editor_returns_value_after_set() {
+        let dir = TempDir::new().unwrap();
+        let api = make_api(&dir);
+        api.set_editor(Json(EditorCommandPayload {
+            editor_command: Some("cursor".to_string()),
+        }))
+        .await
+        .unwrap();
+        let result = api.get_editor().await.unwrap();
+        assert_eq!(result.0.editor_command, Some("cursor".to_string()));
+    }
+
+    #[test]
+    fn editor_command_defaults_to_null() {
+        let dir = TempDir::new().unwrap();
+        let ctx = test_ctx(&dir);
+        let result = get_editor_command_from_store(&ctx);
+        assert!(result.is_none());
+    }
+
+    #[test]
+    fn set_editor_command_persists_in_store() {
+        let dir = TempDir::new().unwrap();
+        let ctx = test_ctx(&dir);
+
+        ctx.store.set(EDITOR_COMMAND_KEY, json!("zed"));
+        ctx.store.save().unwrap();
+
+        let result = get_editor_command_from_store(&ctx);
+        assert_eq!(result, Some("zed".to_string()));
+    }
+
+    #[test]
+    fn get_editor_command_from_store_returns_value() {
+        let dir = TempDir::new().unwrap();
+        let ctx = test_ctx(&dir);
+
+        ctx.store.set(EDITOR_COMMAND_KEY, json!("code"));
+        let result = get_editor_command_from_store(&ctx);
+        assert_eq!(result, Some("code".to_string()));
+    }
+
+    #[test]
+    fn delete_editor_command_returns_none() {
+        let dir = TempDir::new().unwrap();
+        let ctx = test_ctx(&dir);
+
+        ctx.store.set(EDITOR_COMMAND_KEY, json!("cursor"));
+        ctx.store.delete(EDITOR_COMMAND_KEY);
+        let result = get_editor_command_from_store(&ctx);
+        assert!(result.is_none());
+    }
+
+    #[test]
+    fn editor_command_survives_reload() {
+        let dir = TempDir::new().unwrap();
+        let store_path = dir.path().join(".storkit_store.json");
+
+        {
+            let ctx = AppContext::new_test(dir.path().to_path_buf());
+            ctx.store.set(EDITOR_COMMAND_KEY, json!("zed"));
+            ctx.store.save().unwrap();
+        }
+
+        // Reload from disk
+        let store2 = crate::store::JsonFileStore::new(store_path).unwrap();
+        let val = store2.get(EDITOR_COMMAND_KEY);
+        assert_eq!(val, Some(json!("zed")));
+    }
+
+    #[tokio::test]
+    async fn get_editor_http_handler_returns_null_when_not_set() {
+        let dir = TempDir::new().unwrap();
+        let ctx = test_ctx(&dir);
+        let api = SettingsApi {
+            ctx: Arc::new(ctx),
+        };
+        let result = api.get_editor().await.unwrap().0;
+        assert!(result.editor_command.is_none());
+    }
+
+    #[tokio::test]
+    async fn set_editor_http_handler_stores_value() {
+        let dir = TempDir::new().unwrap();
+        let ctx = test_ctx(&dir);
+        let api = SettingsApi {
+            ctx: Arc::new(ctx),
+        };
+        let result = api
+            .set_editor(Json(EditorCommandPayload {
+                editor_command: Some("zed".to_string()),
+            }))
+            .await
+            .unwrap()
+            .0;
+        assert_eq!(result.editor_command, Some("zed".to_string()));
+    }
+
+    #[tokio::test]
+    async fn set_editor_http_handler_clears_value_when_null() {
+        let dir = TempDir::new().unwrap();
+        let ctx = test_ctx(&dir);
+        let api = SettingsApi {
+            ctx: Arc::new(ctx),
+        };
+        // First set a value
+        api.set_editor(Json(EditorCommandPayload {
+            editor_command: Some("code".to_string()),
+        }))
+        .await
+        .unwrap();
+        // Now clear it
+        let result = api
+            .set_editor(Json(EditorCommandPayload {
+                editor_command: None,
+            }))
+            .await
+            .unwrap()
+            .0;
+        assert!(result.editor_command.is_none());
+    }
+
+    #[tokio::test]
+    async fn open_file_returns_error_when_no_editor_configured() {
+        let dir = TempDir::new().unwrap();
+        let api = make_api(&dir);
+        let result = api
+            .open_file(Query("src/main.rs".to_string()), Query(Some(42)))
+            .await;
+        assert!(result.is_err());
+        let err = result.unwrap_err();
+        assert_eq!(err.status(), poem::http::StatusCode::BAD_REQUEST);
+    }
+
+    #[tokio::test]
+    async fn open_file_spawns_editor_with_path_and_line() {
+        let dir = TempDir::new().unwrap();
+        let api = make_api(&dir);
+        // Configure the editor to "echo" which is a safe no-op command
+        api.set_editor(Json(EditorCommandPayload {
+            editor_command: Some("echo".to_string()),
+        }))
+        .await
+        .unwrap();
+        let result = api
+            .open_file(Query("src/main.rs".to_string()), Query(Some(42)))
+            .await
+            .unwrap();
+        assert!(result.0.success);
+    }
+
+    #[tokio::test]
+    async fn open_file_spawns_editor_with_path_only_when_no_line() {
+        let dir = TempDir::new().unwrap();
+        let api = make_api(&dir);
+        api.set_editor(Json(EditorCommandPayload {
+            editor_command: Some("echo".to_string()),
+        }))
+        .await
+        .unwrap();
+        let result = api
+            .open_file(Query("src/lib.rs".to_string()), Query(None))
+            .await
+            .unwrap();
+        assert!(result.0.success);
+    }
+
+    #[tokio::test]
+    async fn open_file_returns_error_for_nonexistent_editor() {
+        let dir = TempDir::new().unwrap();
+        let api = make_api(&dir);
+        api.set_editor(Json(EditorCommandPayload {
+            editor_command: Some("this_editor_does_not_exist_xyz_abc".to_string()),
+        }))
+        .await
+        .unwrap();
+        let result = api
+            .open_file(Query("src/main.rs".to_string()), Query(Some(1)))
+            .await;
+        assert!(result.is_err());
+    }
+}