feat(infrastructure,backend,app-tauri,frontend): tools MCP workspace natifs read-only idea_workspace_map/list/read/search, activés par défaut et configurables dans les permissions MCP et les templates — #341 (QA verte)

crates/backend/src/openai_tools.rs

@@ -1,7 +1,8 @@
 //! ToolInvoker for the OpenAI-compatible adapter.
 //!
 //! C'est la porte locale qui donne aux modèles HTTP la même surface `idea_*` que
-//! le serveur MCP : même catalogue, même mapping en `OrchestratorCommand`, même
+//! le serveur MCP : même catalogue et même policy. Les outils spécialisés
+//! utilisent leurs providers dédiés ; les commandes d'orchestration passent par
 //! `OrchestratorService::dispatch`.
 
 use std::str::FromStr;
@@ -15,7 +16,10 @@ use domain::ports::{
 };
 use domain::{AgentToolPolicy, IssueRef, McpToolPolicy, Project};
 use infrastructure::orchestrator::mcp::PluginToolProvider;
-use infrastructure::{ManagedTempToolProvider, TemplateToolProvider, TicketToolProvider};
+use infrastructure::{
+    FsWorkspaceToolProvider, ManagedTempToolProvider, TemplateToolProvider, TicketToolProvider,
+    WorkspaceToolProvider,
+};
 use serde_json::Value;
 
 const PROJECT_ROOT_ARG: &str = "__ideaProjectRoot";
@@ -31,6 +35,7 @@ pub struct AppOpenAiToolInvoker {
     template_tools: Arc<dyn TemplateToolProvider>,
     managed_temp_tools: Arc<dyn ManagedTempToolProvider>,
     plugin_tools: Arc<dyn PluginToolProvider>,
+    workspace_tools: Arc<dyn WorkspaceToolProvider>,
 }
 
 /// Proxy injecté avant que l'orchestrateur soit construit, puis lié dans la
@@ -116,8 +121,16 @@ impl AppOpenAiToolInvoker {
             template_tools,
             managed_temp_tools,
             plugin_tools,
+            workspace_tools: Arc::new(FsWorkspaceToolProvider::new()),
         }
     }
+
+    /// Replaces the default filesystem workspace adapter at the composition root.
+    #[must_use]
+    pub fn with_workspace_tools(mut self, workspace_tools: Arc<dyn WorkspaceToolProvider>) -> Self {
+        self.workspace_tools = workspace_tools;
+        self
+    }
 }
 
 #[async_trait]
@@ -249,6 +262,24 @@ impl ToolInvoker for AppOpenAiToolInvoker {
             return serde_json::to_string(&value)
                 .map_err(|e| ToolInvocationError::Execution(format!("JSON plugin tool: {e}")));
         }
+        if infrastructure::orchestrator::mcp::tools::is_workspace_tool(name) {
+            let mut workspace_arguments = value;
+            if let Some(arguments) = workspace_arguments.as_object_mut() {
+                arguments.remove(PROJECT_ROOT_ARG);
+                arguments.remove(REQUESTER_ARG);
+            }
+            let value = self
+                .workspace_tools
+                .handle_workspace_tool(&project, &requester, name, workspace_arguments)
+                .await
+                .map_err(|e| {
+                    let detail =
+                        serde_json::to_string(&e.to_value()).unwrap_or_else(|_| e.to_string());
+                    ToolInvocationError::Execution(detail)
+                })?;
+            return serde_json::to_string(&value)
+                .map_err(|e| ToolInvocationError::Execution(format!("JSON workspace tool: {e}")));
+        }
         let command = infrastructure::orchestrator::mcp::map_tool_call(name, &value, &requester)
             .map_err(|e| match e {
                 infrastructure::orchestrator::mcp::ToolMapError::UnknownTool(tool) => {
@@ -961,6 +992,71 @@ mod tests {
         let _ = std::fs::remove_dir_all(temp);
     }
 
+    #[tokio::test]
+    async fn openai_workspace_tools_are_listed_and_use_the_workspace_provider() {
+        let temp =
+            std::env::temp_dir().join(format!("idea-openai-workspace-tools-{}", Uuid::new_v4()));
+        std::fs::create_dir_all(temp.join("src")).unwrap();
+        std::fs::write(temp.join("src/lib.rs"), "pub fn workspace_marker() {}\n").unwrap();
+        let root = temp.to_string_lossy().into_owned();
+        let workspace_project = Project::new(
+            ProjectId::from_uuid(Uuid::from_u128(341)),
+            "workspace-tools",
+            ProjectPath::new(root.clone()).unwrap(),
+            RemoteRef::local(),
+            1_000,
+        )
+        .unwrap();
+        let core = crate::BackendCore::build(temp.join("state"));
+        let requester = AgentId::from_uuid(Uuid::from_u128(341)).to_string();
+        let invoker = AppOpenAiToolInvoker::new(
+            Arc::clone(&core.orchestrator_service),
+            Arc::new(FakeProjects::with(workspace_project)) as Arc<dyn ProjectStore>,
+            Arc::new(FakePolicies::default()),
+            mcp_permissions(ProjectMcpToolPermissions::default()),
+            Arc::new(FakeTicketTools::default()),
+            Arc::new(FakeTemplateTools::default()),
+            fake_managed_temp_tools(),
+            fake_plugin_tools(),
+        );
+
+        let tools = invoker
+            .tools_for_context(&root, &requester)
+            .await
+            .expect("default read-only catalogue");
+        let names = tools
+            .iter()
+            .map(|tool| tool.name.as_str())
+            .collect::<Vec<_>>();
+        for name in [
+            "idea_workspace_map",
+            "idea_workspace_list",
+            "idea_workspace_read",
+            "idea_workspace_search",
+        ] {
+            assert!(names.contains(&name), "missing {name}");
+        }
+
+        let result = invoker
+            .call(
+                "idea_workspace_search",
+                &json!({
+                    PROJECT_ROOT_ARG: root,
+                    REQUESTER_ARG: requester,
+                    "query": "workspace_marker",
+                    "path": "src",
+                })
+                .to_string(),
+            )
+            .await
+            .expect("workspace search should use its dedicated provider");
+        let result: Value = serde_json::from_str(&result).unwrap();
+        assert_eq!(result["matches"][0]["path"], "src/lib.rs");
+        assert_eq!(result["matches"][0]["line"], 1);
+
+        let _ = std::fs::remove_dir_all(temp);
+    }
+
     #[tokio::test]
     async fn openai_tools_list_matches_durable_agent_policy() {
         let temp =