Merge branch 'main' into release

Author: ndhkaeru

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "codebase-mcp"
-version = "1.3.0"
+version = "1.3.1"
 edition = "2024"
 license = "Apache-2.0"
 description = "High-performance MCP server for filesystem and code intelligence workflows"

Cargo.toml

@@ -360,29 +360,13 @@ tests/                 integration and behavior tests
 ## Project Status
 
 - **Package:** `codebase-mcp`
-- **Version:** `1.3.0`
+- **Version:** `1.3.1`
 - **Runtime:** Rust + Tokio
 - **Transport:** MCP `stdio`
 - **MCP protocol version:** `2024-11-05`
 - **Tool count:** 25
 - **License:** Apache-2.0
 
-### Release Notes - 1.3.0
-
-- Slims the exposed MCP toolset to core codebase, search, read, edit, and code-intelligence workflows.
-- Removes Markdown, JSON utility, SQLite, diff snippet, and undo/redo command tools from the public catalog.
-- Simplifies runtime configuration and workspace-root handling for session-aware clients.
-- Tunes default indexing limits for large Chromium-sized workspaces.
-- Adds server instructions and richer tool parameter descriptions to improve agent tool selection.
-
-### Release Notes - 1.2.1
-
-- Adds Swift and Objective-C language support for AST-backed tools.
-- Improves import/export handling for Swift and Objective-C.
-- Formats workspace stats imports.
-- Fixes Clippy sort warnings.
-- Refreshes README project information.
-
 ---
 
 ## Acknowledgements

README.md

@@ -191,7 +191,72 @@ pub fn resolve_tool_path(raw: &str) -> PathBuf {
         return canonicalize_if_exists(path);
     }
 
-    canonicalize_if_exists(default_tool_root().join(path))
+    canonicalize_if_exists(resolve_relative_tool_path(&path))
+}
+
+fn resolve_relative_tool_path(path: &Path) -> PathBuf {
+    let mut roots = Vec::new();
+
+    if let Some((root, _)) = preferred_workspace_root() {
+        push_unique_path(&mut roots, root);
+    }
+
+    for runtime in crate::indexer::get_runtime_snapshots() {
+        let root = canonicalize_if_exists(PathBuf::from(runtime.workspace_root));
+        push_unique_path(&mut roots, root.clone());
+        if let Some(parent) = root.parent() {
+            push_unique_path(&mut roots, parent.to_path_buf());
+        }
+    }
+
+    if let Ok(current_dir) = std::env::current_dir() {
+        if let Some(root) = discover_workspace_root(&current_dir) {
+            push_unique_path(&mut roots, root);
+        }
+        push_unique_path(&mut roots, canonicalize_if_exists(current_dir));
+    }
+
+    roots
+        .into_iter()
+        .map(|root| root.join(path))
+        .max_by_key(|candidate| existing_ancestor_depth(candidate))
+        .unwrap_or_else(|| PathBuf::from(path))
+}
+
+fn push_unique_path(paths: &mut Vec<PathBuf>, candidate: PathBuf) {
+    let candidate_key = normalize_path_key(&candidate);
+    if paths
+        .iter()
+        .any(|existing| normalize_path_key(existing) == candidate_key)
+    {
+        return;
+    }
+
+    paths.push(candidate);
+}
+
+fn existing_ancestor_depth(path: &Path) -> usize {
+    let mut current = Some(path);
+    while let Some(candidate) = current {
+        if candidate.exists() {
+            return candidate.components().count();
+        }
+        current = candidate.parent();
+    }
+
+    0
+}
+
+fn normalize_path_key(path: &Path) -> String {
+    let normalized = path.to_string_lossy().replace('\\', "/");
+    #[cfg(windows)]
+    {
+        normalized.to_ascii_lowercase()
+    }
+    #[cfg(not(windows))]
+    {
+        normalized
+    }
 }
 
 pub fn bounded_walk_threads() -> usize {

src/common.rs

@@ -167,6 +167,59 @@ fn call_binary_server_tool_then_health(
     )
 }
 
+fn call_binary_server_tools(
+    current_dir: &Path,
+    initialize_params: Value,
+    tool_calls: Vec<(&str, Value)>,
+    settle_ms: u64,
+) -> Vec<Value> {
+    let exe = server_binary();
+    let mut command = Command::new(&exe);
+    command
+        .current_dir(current_dir)
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped());
+    let mut child = command.spawn().unwrap();
+
+    {
+        let stdin = child.stdin.as_mut().unwrap();
+        writeln!(
+            stdin,
+            "{}",
+            json!({"jsonrpc":"2.0","id":1,"method":"initialize","params":initialize_params})
+        )
+        .unwrap();
+        writeln!(
+            stdin,
+            "{}",
+            json!({"jsonrpc":"2.0","method":"notifications/initialized"})
+        )
+        .unwrap();
+        stdin.flush().unwrap();
+        thread::sleep(Duration::from_millis(settle_ms));
+
+        for (index, (tool_name, tool_arguments)) in tool_calls.into_iter().enumerate() {
+            writeln!(
+                stdin,
+                "{}",
+                json!({"jsonrpc":"2.0","id":index + 2,"method":"tools/call","params":{"name":tool_name,"arguments":tool_arguments}})
+            )
+            .unwrap();
+        }
+    }
+
+    let output = child.wait_with_output().unwrap();
+    let stdout = String::from_utf8(output.stdout).unwrap();
+    stdout
+        .lines()
+        .filter(|line| line.trim_start().starts_with('{'))
+        .filter_map(|line| serde_json::from_str::<Value>(line).ok())
+        .filter(|response| response.get("id").and_then(|v| v.as_i64()).unwrap_or(0) >= 2)
+        .map(|response| decode_tool_rpc_response(&response))
+        .collect()
+}
+
 fn decode_tool_rpc_response(rpc: &Value) -> Value {
     serde_json::from_str(
         rpc.get("result")
@@ -524,6 +577,69 @@ fn test_tool_call_auto_indexes_workspace_from_request_path() {
     );
 }
 
+#[test]
+fn test_relative_paths_can_target_sibling_workspace_after_active_child_changes() {
+    let current_dir = tempdir().unwrap();
+    let workspace = tempdir().unwrap();
+    let api_dir = workspace.path().join("workboardapi");
+    let ui_dir = workspace.path().join("workboardui");
+    let api_search_dir = api_dir.join("src/redmine-sync");
+    let ui_search_dir = ui_dir.join("src/app/features/task-current");
+    fs::create_dir_all(&api_search_dir).unwrap();
+    fs::create_dir_all(&ui_search_dir).unwrap();
+    fs::write(
+        api_dir.join("Cargo.toml"),
+        "[package]\nname = \"api\"\nversion = \"0.1.0\"\n",
+    )
+    .unwrap();
+    fs::write(ui_dir.join("package.json"), "{\"name\":\"ui\"}\n").unwrap();
+    fs::write(api_search_dir.join("import.rs"), "fn basicImport() {}\n").unwrap();
+    fs::write(
+        ui_search_dir.join("import.ts"),
+        "export const basicImport = true;\n",
+    )
+    .unwrap();
+
+    let responses = call_binary_server_tools(
+        current_dir.path(),
+        json!({
+            "workspaceFolders": [
+                { "uri": file_uri_for_test(workspace.path()) }
+            ]
+        }),
+        vec![
+            ("resolve_path", json!({ "path": api_dir.to_str().unwrap() })),
+            (
+                "text_search",
+                json!({
+                    "paths": [
+                        "workboardapi/src/redmine-sync",
+                        "workboardui/src/app/features/task-current"
+                    ],
+                    "query": "basicImport",
+                    "max_results": 50,
+                    "context_lines": 2
+                }),
+            ),
+        ],
+        300,
+    );
+
+    let text_search_result = responses.last().unwrap();
+    assert_eq!(
+        text_search_result
+            .get("total_returned")
+            .and_then(|v| v.as_u64()),
+        Some(2)
+    );
+    assert_eq!(
+        text_search_result
+            .get("files_searched")
+            .and_then(|v| v.as_u64()),
+        Some(2)
+    );
+}
+
 #[test]
 fn test_tool_call_switches_active_workspace_context() {
     let current_dir = tempdir().unwrap();