@@ -8478,6 +8478,189 @@ TEST(tool_search_graph_accepts_project_name_alias_issue640) {
84788478 PASS();
84798479}
84808480
8481+ /* #1690: the installed skill tells an agent to pass its absolute working
8482+ * directory (or the list_projects name whose root_path contains it) as
8483+ * `project`, never a guessed repo or folder name. A path-shaped project used to
8484+ * be turned into the path-DERIVED name only, so it missed a checkout indexed
8485+ * under an explicit name and every directory below an indexed root: the agent
8486+ * got "project not found" and dropped the graph. It must resolve to the indexed
8487+ * project whose stored root_path owns the path, whatever that project is
8488+ * called; the deepest owning root wins, and two owners of one root are never
8489+ * guessed between. */
8490+ static char *i1690_search(cbm_mcp_server_t *srv, const char *project) {
8491+ char args[CBM_SZ_4K];
8492+ snprintf(args, sizeof(args), "{\"project\":\"%s\",\"name_pattern\":\".*_fn_1690\"}", project);
8493+ return cbm_mcp_handle_tool(srv, "search_graph", args);
8494+ }
8495+
8496+ static char *i1690_index(cbm_mcp_server_t *srv, const char *repo, const char *name) {
8497+ char args[CBM_SZ_4K];
8498+ if (name) {
8499+ snprintf(args, sizeof(args), "{\"repo_path\":\"%s\",\"name\":\"%s\"}", repo, name);
8500+ } else {
8501+ snprintf(args, sizeof(args), "{\"repo_path\":\"%s\"}", repo);
8502+ }
8503+ return cbm_mcp_handle_tool(srv, "index_repository", args);
8504+ }
8505+
8506+ TEST(tool_project_path_resolves_owning_project_issue1690) {
8507+ char tmp[CBM_SZ_256];
8508+ char cache[CBM_SZ_256];
8509+ snprintf(tmp, sizeof(tmp), "/tmp/cbm-i1690r-XXXXXX");
8510+ snprintf(cache, sizeof(cache), "/tmp/cbm-i1690c-XXXXXX");
8511+ if (!cbm_mkdtemp(tmp) || !cbm_mkdtemp(cache)) {
8512+ FAIL("mkdtemp failed");
8513+ }
8514+ /* Forward slashes keep the JSON arguments valid on every platform. */
8515+ char base[CBM_SZ_4K]; /* cbm_canonical_path needs >= 4096 bytes */
8516+ if (!cbm_canonical_path(tmp, base, sizeof(base))) {
8517+ FAIL("cbm_canonical_path failed");
8518+ }
8519+ cbm_normalize_path_sep(base);
8520+ const char *saved_cache = getenv("CBM_CACHE_DIR");
8521+ char *saved_cache_copy = saved_cache ? cbm_strdup(saved_cache) : NULL;
8522+ const char *saved_sup = getenv("CBM_INDEX_SUPERVISOR");
8523+ char *saved_sup_copy = saved_sup ? cbm_strdup(saved_sup) : NULL;
8524+ cbm_setenv("CBM_CACHE_DIR", cache, 1);
8525+ cbm_setenv("CBM_INDEX_SUPERVISOR", "0", 1);
8526+
8527+ /* some_name: the checkout of "repo_name", indexed under that explicit name.
8528+ * some_name2: a similarly named checkout indexed by path (derived name).
8529+ * some_name_x: shares the "some_name" prefix and is NOT indexed.
8530+ * twin_root: one root indexed under two explicit names. */
8531+ char named[CBM_SZ_4K];
8532+ char named_sub[CBM_SZ_4K];
8533+ char similar[CBM_SZ_4K];
8534+ char similar_sub[CBM_SZ_4K];
8535+ char unindexed[CBM_SZ_4K];
8536+ char twin[CBM_SZ_4K];
8537+ snprintf(named, sizeof(named), "%s/some_name", base);
8538+ snprintf(named_sub, sizeof(named_sub), "%s/some_name/pkg", base);
8539+ snprintf(similar, sizeof(similar), "%s/some_name2", base);
8540+ snprintf(similar_sub, sizeof(similar_sub), "%s/some_name2/pkg", base);
8541+ snprintf(unindexed, sizeof(unindexed), "%s/some_name_x", base);
8542+ snprintf(twin, sizeof(twin), "%s/twin_root", base);
8543+ ASSERT_EQ(th_write_file(TH_PATH(named, "app.py"), "def named_fn_1690(x):\n return x\n"), 0);
8544+ ASSERT_EQ(th_write_file(TH_PATH(named_sub, "entry.py"), "def sub_fn_1690():\n return 1\n"),
8545+ 0);
8546+ ASSERT_EQ(th_write_file(TH_PATH(similar, "app.py"), "def similar_fn_1690(x):\n return x\n"),
8547+ 0);
8548+ ASSERT_EQ(
8549+ th_write_file(TH_PATH(similar_sub, "entry.py"), "def deep_fn_1690():\n return 2\n"), 0);
8550+ ASSERT_EQ(th_write_file(TH_PATH(unindexed, "app.py"), "def stray_fn_1690():\n return 3\n"),
8551+ 0);
8552+ ASSERT_EQ(th_write_file(TH_PATH(twin, "app.py"), "def twin_fn_1690():\n return 4\n"), 0);
8553+
8554+ cbm_mcp_server_t *srv = cbm_mcp_server_new(NULL);
8555+ ASSERT_NOT_NULL(srv);
8556+ char *r = i1690_index(srv, named, "repo_name1690");
8557+ ASSERT_NOT_NULL(r);
8558+ ASSERT_NOT_NULL(strstr(r, "repo_name1690"));
8559+ free(r);
8560+ r = i1690_index(srv, similar, NULL);
8561+ ASSERT_NOT_NULL(r);
8562+ ASSERT_NULL(strstr(r, "\"isError\":true"));
8563+ free(r);
8564+ r = i1690_index(srv, twin, "twin1690a");
8565+ ASSERT_NOT_NULL(r);
8566+ free(r);
8567+ r = i1690_index(srv, twin, "twin1690b");
8568+ ASSERT_NOT_NULL(r);
8569+ free(r);
8570+
8571+ /* 1. The explicitly named checkout's root path resolves to that project
8572+ * (RED before the fix: the derived name has no index). */
8573+ r = i1690_search(srv, named);
8574+ ASSERT_NOT_NULL(r);
8575+ if (strstr(r, "project not found")) {
8576+ fprintf(stderr, " [1690] FAIL named root path did not resolve: %.300s\n", r);
8577+ }
8578+ ASSERT_NULL(strstr(r, "project not found"));
8579+ ASSERT_NOT_NULL(strstr(r, "named_fn_1690"));
8580+ ASSERT_NULL(strstr(r, "similar_fn_1690"));
8581+ free(r);
8582+
8583+ /* 2. A working directory below that root resolves to the same project. */
8584+ r = i1690_search(srv, named_sub);
8585+ ASSERT_NOT_NULL(r);
8586+ if (strstr(r, "project not found")) {
8587+ fprintf(stderr, " [1690] FAIL subdirectory path did not resolve: %.300s\n", r);
8588+ }
8589+ ASSERT_NULL(strstr(r, "project not found"));
8590+ ASSERT_NOT_NULL(strstr(r, "sub_fn_1690"));
8591+ free(r);
8592+
8593+ /* 3. index_status names the resolved identity, not the derived name. */
8594+ char status_args[CBM_SZ_4K];
8595+ snprintf(status_args, sizeof(status_args), "{\"project\":\"%s\",\"format\":\"json\"}",
8596+ named_sub);
8597+ r = cbm_mcp_handle_tool(srv, "index_status", status_args);
8598+ ASSERT_NOT_NULL(r);
8599+ char *status = extract_text_content(r);
8600+ ASSERT_NOT_NULL(status);
8601+ ASSERT_NOT_NULL(strstr(status, "\"project\":\"repo_name1690\""));
8602+ free(status);
8603+ free(r);
8604+
8605+ /* 4. Control, normal naming: a path-derived project resolves as before,
8606+ * and its subdirectory resolves to it, never to the similar name. */
8607+ r = i1690_search(srv, similar);
8608+ ASSERT_NOT_NULL(r);
8609+ ASSERT_NOT_NULL(strstr(r, "similar_fn_1690"));
8610+ ASSERT_NULL(strstr(r, "named_fn_1690"));
8611+ free(r);
8612+ r = i1690_search(srv, similar_sub);
8613+ ASSERT_NOT_NULL(r);
8614+ ASSERT_NULL(strstr(r, "project not found"));
8615+ ASSERT_NOT_NULL(strstr(r, "deep_fn_1690"));
8616+ ASSERT_NULL(strstr(r, "named_fn_1690"));
8617+ free(r);
8618+
8619+ /* 5. Control, similar names: a sibling that only shares the "some_name"
8620+ * prefix is owned by no project and must not borrow one. */
8621+ r = i1690_search(srv, unindexed);
8622+ ASSERT_NOT_NULL(r);
8623+ ASSERT_NOT_NULL(strstr(r, "project not found"));
8624+ free(r);
8625+
8626+ /* 6. Two projects owning one root are ambiguous: never guess. */
8627+ r = i1690_search(srv, twin);
8628+ ASSERT_NOT_NULL(r);
8629+ ASSERT_NOT_NULL(strstr(r, "project not found"));
8630+ free(r);
8631+
8632+ /* 7. Control: the exact explicit name keeps working. */
8633+ r = i1690_search(srv, "repo_name1690");
8634+ ASSERT_NOT_NULL(r);
8635+ ASSERT_NOT_NULL(strstr(r, "named_fn_1690"));
8636+ free(r);
8637+
8638+ /* 8. A guessed repo name stays unresolved (nothing is guessed), but the
8639+ * error says how to pick the project so the agent can recover. */
8640+ r = i1690_search(srv, "repo_name");
8641+ ASSERT_NOT_NULL(r);
8642+ ASSERT_NOT_NULL(strstr(r, "project not found"));
8643+ ASSERT_NOT_NULL(strstr(r, "root_path contains your working directory"));
8644+ free(r);
8645+
8646+ cbm_mcp_server_free(srv);
8647+ if (saved_cache_copy) {
8648+ cbm_setenv("CBM_CACHE_DIR", saved_cache_copy, 1);
8649+ free(saved_cache_copy);
8650+ } else {
8651+ cbm_unsetenv("CBM_CACHE_DIR");
8652+ }
8653+ if (saved_sup_copy) {
8654+ cbm_setenv("CBM_INDEX_SUPERVISOR", saved_sup_copy, 1);
8655+ free(saved_sup_copy);
8656+ } else {
8657+ cbm_unsetenv("CBM_INDEX_SUPERVISOR");
8658+ }
8659+ th_rmtree(tmp);
8660+ th_rmtree(cache);
8661+ PASS();
8662+ }
8663+
84818664/* #1025: agents pass the repo FOLDER name ("codebase-memory-mcp"), but
84828665 * indexed project names derive from the full path
84838666 * (E:\project\graph\x -> "E-project-graph-x"), so exact lookup fails with
@@ -21188,6 +21371,7 @@ SUITE(mcp) {
2118821371 RUN_TEST(tool_get_architecture_rejects_unknown_aspect_pr560);
2118921372 RUN_TEST(tool_get_architecture_accepts_project_name_alias_issue640);
2119021373 RUN_TEST(tool_search_graph_accepts_project_name_alias_issue640);
21374+ RUN_TEST(tool_project_path_resolves_owning_project_issue1690);
2119121375 RUN_TEST(tool_project_arg_resolves_unique_tail_issue1025);
2119221376 RUN_TEST(tool_project_arg_resolves_non_ascii_folder_issue1827);
2119321377 RUN_TEST(tool_index_repository_reuses_existing_project_for_root_issue2134);
0 commit comments