fix(mcp): match search_code file_pattern with a directory against the repo-relative path

.claude-plugin/marketplace.json

@@ -0,0 +1,15 @@
+{
+  "name": "codebase-memory",
+  "description": "The codebase-memory-mcp code knowledge graph server, as a Claude Code plugin.",
+  "owner": {
+    "name": "DeusData",
+    "url": "https://github.com/DeusData"
+  },
+  "plugins": [
+    {
+      "name": "codebase-memory",
+      "source": "./plugin",
+      "description": "Codebase knowledge graph for AI agents: sub-ms queries, 99% fewer tokens."
+    }
+  ]
+}

.gitignore

@@ -33,6 +33,8 @@ Thumbs.db
 
 # MCP config (user-local, generated by install command)
 .mcp.json
+# ...except the Claude Code plugin's server definition, which is published
+!plugin/.mcp.json
 
 # MCP Registry auth tokens
 .mcpregistry_*

README.md

@@ -578,6 +578,30 @@ Working in a clone? Use `.` in place of the flake URL, e.g. `nix run .#codebase-
 You: "Install this MCP server: https://github.com/DeusData/codebase-memory-mcp"
 ```
 
+### Install via Claude Code plugin
+
+This repository is also a Claude Code plugin marketplace, so you can find and
+add the server from inside Claude Code:
+
+```bash
+claude plugin marketplace add DeusData/codebase-memory-mcp
+claude plugin install codebase-memory@codebase-memory
+```
+
+The plugin registers the MCP server only. It starts the server with
+`npx -y codebase-memory-mcp@<version>`, pinned to the current release; the first
+start downloads that release's binary through the npm package, which verifies
+it against the release checksums. The skill, the three graph agents and the
+context hooks are not part of the plugin: they come from
+`codebase-memory-mcp install`.
+
+Use one or the other. `install` registers the same server for Claude Code, so
+with both you run it twice, under two tool namespaces
+(`mcp__codebase-memory-mcp__*` and
+`mcp__plugin_codebase-memory_codebase-memory-mcp__*`). Choose `install` for the
+full Claude Code setup; choose the plugin to add just the server without
+running an installer.
+
 ### Build from Source
 
 <details>

internal/cbm/cbm.h

@@ -298,9 +298,10 @@ typedef struct {
      * are bound to the owning result's source identity before cross-file use. */
     uint32_t test_name_start_byte, test_name_end_byte;
     uint32_t test_body_start_byte, test_body_end_byte;
-    /* Documents only: facts a document definition adds to its node's
-     * properties, as a NULL-terminated key, value, key, value, ... list (an
-     * ADR's id, status, date, deciders, title). Keys are fixed literals; the
+    /* Facts a definition adds to its node's properties, as a NULL-terminated
+     * key, value, key, value, ... list: a document's (an ADR's id, status,
+     * date, deciders, title), or CBM_PROP_GENERATED on a member the compiler
+     * writes and the source never spells. Keys are fixed literals; the
      * values are escaped where the properties are written. Tail field:
      * zero-init stays valid. */
     const char **extra_props;
@@ -321,6 +322,13 @@ typedef struct {
     const char *alias_target;
 } CBMDefinition;
 
+/* extra_props key of a generated member, one the compiler writes and the
+ * source never spells: a Java record's implicit accessor carries
+ * `generated: record`. The node keeps the property, and the pipeline registers
+ * such a definition by qualified name only, so no short-name guess can land on
+ * it (pipeline.h cbm_def_props_generated). */
+#define CBM_PROP_GENERATED "generated"
+
 /* Argument captured from a call expression */
 typedef struct {
     const char *expr;      // raw expression text ("payload.info", "MY_URL", "'hello'")

internal/cbm/extract_defs.c

@@ -230,6 +230,7 @@ static void extract_class_fields(CBMExtractCtx *ctx, TSNode class_node, const ch
                                  const CBMLangSpec *spec);
 static TSNode find_class_body(TSNode class_node, CBMLanguage lang);
 static void extract_enum_members(CBMExtractCtx *ctx, TSNode node, const char *class_qn);
+static void extract_record_accessors(CBMExtractCtx *ctx, TSNode node, const char *class_qn);
 static void extract_elixir_call(CBMExtractCtx *ctx, TSNode node, const CBMLangSpec *spec);
 
 // --- Helpers ---
@@ -8317,6 +8318,10 @@ static void emit_class_def(CBMExtractCtx *ctx, TSNode node, const CBMLangSpec *s
         extract_enum_members(ctx, node, class_qn);
     }
 
+    if (ctx->language == CBM_LANG_JAVA && strcmp(kind, "record_declaration") == 0) {
+        extract_record_accessors(ctx, node, class_qn);
+    }
+
     // Extract methods inside the class
     int methods_from = ctx->result->defs.count;
     extract_class_methods(ctx, node, class_qn, spec);
@@ -9642,6 +9647,121 @@ static void extract_enum_members(CBMExtractCtx *ctx, TSNode node, const char *cl
     }
 }
 
+/* Whether the record body declares this accessor itself (JLS §8.10.3 lets a
+ * record override any of them), so the implicit one is not emitted twice. */
+static bool record_declares_accessor(CBMExtractCtx *ctx, TSNode node, const char *comp_name) {
+    TSNode body = find_class_body(node, ctx->language);
+    if (ts_node_is_null(body)) {
+        return false;
+    }
+    uint32_t mc = ts_node_named_child_count(body);
+    for (uint32_t mi = 0; mi < mc; mi++) {
+        TSNode member = ts_node_named_child(body, mi);
+        if (strcmp(ts_node_type(member), "method_declaration") != 0) {
+            continue;
+        }
+        TSNode mname = ts_node_child_by_field_name(member, TS_FIELD("name"));
+        if (ts_node_is_null(mname)) {
+            continue;
+        }
+        char *name = cbm_node_text(ctx->arena, mname, ctx->source);
+        if (!name || strcmp(name, comp_name) != 0) {
+            continue;
+        }
+        /* Same name, no parameters — that is the accessor. */
+        TSNode params = ts_node_child_by_field_name(member, TS_FIELD("parameters"));
+        if (ts_node_is_null(params)) {
+            return true;
+        }
+        /* Comments are named extras, not parameters. */
+        bool has_parameters = false;
+        uint32_t pc = ts_node_named_child_count(params);
+        for (uint32_t pi = 0; pi < pc; pi++) {
+            if (!ts_node_is_extra(ts_node_named_child(params, pi))) {
+                has_parameters = true;
+                break;
+            }
+        }
+        if (!has_parameters) {
+            return true;
+        }
+    }
+    return false;
+}
+
+/* Java records: the compiler writes one accessor per component, so `p.x()`
+ * calls a method that appears nowhere in the source. Without a definition for
+ * it the call has nothing to resolve to and falls through to the project-wide
+ * name registry, which binds it to the first `x` in the tree — typically an
+ * unrelated class's private field. Emitting the accessors makes the record's
+ * own API visible, exactly as the language defines it (JLS §8.10.3). */
+static void extract_record_accessors(CBMExtractCtx *ctx, TSNode node, const char *class_qn) {
+    CBMArena *a = ctx->arena;
+    TSNode params = ts_node_child_by_field_name(node, TS_FIELD("parameters"));
+    if (ts_node_is_null(params)) {
+        return;
+    }
+    uint32_t pc = ts_node_named_child_count(params);
+    for (uint32_t pi = 0; pi < pc; pi++) {
+        TSNode comp = ts_node_named_child(params, pi);
+        bool spread = strcmp(ts_node_type(comp), "spread_parameter") == 0;
+        if (!spread && strcmp(ts_node_type(comp), "formal_parameter") != 0) {
+            continue;
+        }
+        TSNode cname = ts_node_child_by_field_name(comp, TS_FIELD("name"));
+        TSNode ctype = ts_node_child_by_field_name(comp, TS_FIELD("type"));
+        if (spread) {
+            /* Java varargs have an unnamed type child and a nested declarator. */
+            TSNode decl = cbm_find_child_by_kind(comp, "variable_declarator");
+            if (ts_node_is_null(decl)) {
+                continue;
+            }
+            cname = ts_node_child_by_field_name(decl, TS_FIELD("name"));
+            uint32_t nc = ts_node_named_child_count(comp);
+            for (uint32_t ci = 0; ci < nc; ci++) {
+                TSNode child = ts_node_named_child(comp, ci);
+                if (!ts_node_is_extra(child) && strcmp(ts_node_type(child), "modifiers") != 0) {
+                    ctype = child;
+                    break;
+                }
+            }
+        }
+        if (ts_node_is_null(cname)) {
+            continue;
+        }
+        char *comp_name = cbm_node_text(a, cname, ctx->source);
+        if (!comp_name || !comp_name[0] || record_declares_accessor(ctx, node, comp_name)) {
+            continue;
+        }
+        CBMDefinition adef;
+        memset(&adef, 0, sizeof(adef));
+        adef.name = comp_name;
+        adef.qualified_name = cbm_arena_sprintf(a, "%s.%s", class_qn, comp_name);
+        adef.label = "Method";
+        adef.file_path = ctx->rel_path;
+        adef.start_line = ts_node_start_point(comp).row + TS_LINE_OFFSET;
+        adef.end_line = ts_node_end_point(comp).row + TS_LINE_OFFSET;
+        adef.lines = 1;
+        adef.parent_class = class_qn;
+        adef.is_exported = true;
+        if (!ts_node_is_null(ctype)) {
+            const char *type = cbm_node_text(a, ctype, ctx->source);
+            adef.return_type = spread && type ? cbm_arena_sprintf(a, "%s[]", type) : type;
+        }
+        /* The compiler writes this member and the source never spells it: its
+         * node says so, and the pipeline registers it by qualified name only,
+         * so no short-name guess can land on it. */
+        const char **kv = (const char **)cbm_arena_alloc(a, CBM_SZ_3 * sizeof(char *));
+        if (kv) {
+            kv[0] = CBM_PROP_GENERATED;
+            kv[SKIP_ONE] = "record";
+            kv[PAIR_LEN] = NULL;
+        }
+        adef.extra_props = kv;
+        cbm_defs_push(&ctx->result->defs, a, adef);
+    }
+}
+
 /* Resolve the identifier node from a destructure pattern child.
  * pair_pattern → value field; shorthand/identifier → itself; others → first named child. */
 static TSNode destructure_ident(TSNode pat_child) {

internal/cbm/lsp/py_lsp.c

@@ -6179,10 +6179,36 @@ static void py_split_field_defs(CBMArena *arena, const char *field_defs, const c
     *types_out = types;
 }
 
+/* Qualified names of reg->types[0..noted), for a caller that registers into a
+ * registry it does not finalize until the end (cbm_py_build_cross_registry):
+ * that registry's own lookup scans every type. qns == NULL probes the
+ * registry instead. */
+typedef struct {
+    CBMHashTable *qns;
+    int noted;
+} PyKnownTypes;
+
+/* Note the types added since the last call. Run after every add_type, so an
+ * add that failed silently cannot desync set and registry. If the set cannot
+ * grow it is dropped and probes fall back to the registry. */
+static void py_note_known_types(PyKnownTypes *known, const CBMTypeRegistry *reg) {
+    for (; known && known->qns && known->noted < reg->type_count; known->noted++) {
+        const char *qn = reg->types[known->noted].qualified_name;
+        if (!qn || cbm_ht_has(known->qns, qn))
+            continue;
+        cbm_ht_set(known->qns, qn, (void *)(uintptr_t)(known->noted + 1));
+        if (!cbm_ht_has(known->qns, qn)) {
+            cbm_ht_free(known->qns);
+            known->qns = NULL;
+        }
+    }
+}
+
 /* Build a registry from CBMLSPDef[] supplied by the caller — covers both
- * the source file's own defs and cross-file referenced defs. */
+ * the source file's own defs and cross-file referenced defs. known is NULL
+ * except for the shared Tier-2 build. */
 static bool py_register_lsp_defs(CBMArena *arena, CBMArena *idx_arena, CBMTypeRegistry *reg,
-                                 CBMLSPDef *defs, int def_count) {
+                                 CBMLSPDef *defs, int def_count, PyKnownTypes *known) {
     /* Pass 1: types only — the method pass probes the registry per Method def
      * (receiver auto-registration), which is a LINEAR scan pre-finalize:
      * O(methods x types) per file (same quadratic as php_register_lsp_defs;
@@ -6206,6 +6232,7 @@ static bool py_register_lsp_defs(CBMArena *arena, CBMArena *idx_arena, CBMTypeRe
             }
             py_split_field_defs(arena, d->field_defs, &rt.field_names, &rt.field_types);
             cbm_registry_add_type(reg, rt);
+            py_note_known_types(known, reg);
         }
     }
     /* idx_arena == NULL skips the mid-build finalize: the tier-2 builder
@@ -6259,13 +6286,17 @@ static bool py_register_lsp_defs(CBMArena *arena, CBMArena *idx_arena, CBMTypeRe
 
             if (strcmp(d->label, "Method") == 0 && d->receiver_type && d->receiver_type[0]) {
                 rf.receiver_type = d->receiver_type; /* borrowed */
-                if (!cbm_registry_lookup_type(reg, rf.receiver_type)) {
+                bool recv_known = known && known->qns
+                                      ? cbm_ht_has(known->qns, rf.receiver_type)
+                                      : cbm_registry_lookup_type(reg, rf.receiver_type) != NULL;
+                if (!recv_known) {
                     CBMRegisteredType auto_t;
                     memset(&auto_t, 0, sizeof(auto_t));
                     auto_t.qualified_name = rf.receiver_type;
                     const char *dot = strrchr(d->receiver_type, '.');
                     auto_t.short_name = dot ? dot + 1 : rf.receiver_type; /* borrowed substring */
                     cbm_registry_add_type(reg, auto_t);
+                    py_note_known_types(known, reg);
                 }
             }
             cbm_registry_add_func(reg, rf);
@@ -6277,7 +6308,7 @@ static bool py_register_lsp_defs(CBMArena *arena, CBMArena *idx_arena, CBMTypeRe
 #ifdef CBM_ENABLE_TEST_SEAMS
 bool cbm_py_lsp_test_register_defs(CBMArena *arena, CBMTypeRegistry *reg, CBMLSPDef *defs,
                                    int def_count) {
-    return py_register_lsp_defs(arena, NULL, reg, defs, def_count);
+    return py_register_lsp_defs(arena, NULL, reg, defs, def_count, NULL);
 }
 #endif
 
@@ -6774,7 +6805,7 @@ CBMLSPStatus cbm_run_py_lsp_cross_status(CBMArena *arena, const char *source, in
     py_lsp_init_for_stage(&ctx, arena, source, source_len, &reg, module_qn, out, "cross");
     if (ctx.eval_failure)
         goto cross_cleanup;
-    if (!py_register_lsp_defs(arena, &idx_arena, &reg, defs, def_count)) {
+    if (!py_register_lsp_defs(arena, &idx_arena, &reg, defs, def_count, NULL)) {
         ctx.eval_failure = CBM_LSP_SCOPE_FAILED;
         goto cross_cleanup;
     }
@@ -6813,15 +6844,27 @@ CBMTypeRegistry *cbm_py_build_cross_registry(CBMArena *arena, CBMLSPDef *defs, i
     cbm_registry_init(reg, arena);
     cbm_python_stdlib_register(reg, arena);
 
+    /* The registry is not finalized until the end, so probing it for each
+     * Method's receiver scanned every type: O(methods x types), single-threaded
+     * (~54 s of lsp_cross_prepare on a large Python tree). Probe a set of
+     * the registered type QNs instead; registration order is unchanged. Sized
+     * for the stdlib seed, not def_count (the mixed all-language count). NULL
+     * on allocation failure: the registry probe runs as before. */
+    PyKnownTypes known = {cbm_ht_create((uint32_t)reg->type_count), 0};
+    py_note_known_types(&known, reg);
+
     /* Filter to Python defs only — defs[] is mixed-language all_defs. */
     for (int i = 0; i < def_count; i++) {
         CBMLSPDef *d = &defs[i];
         if (d->lang != CBM_LANG_PYTHON)
             continue;
         /* Reuse the existing register fn on a single-def slice (n=1 inline). */
-        if (!py_register_lsp_defs(arena, NULL, reg, d, 1))
+        if (!py_register_lsp_defs(arena, NULL, reg, d, 1, &known)) {
+            cbm_ht_free(known.qns);
             return NULL; /* caller owns the shared arena and other registries */
+        }
     }
+    cbm_ht_free(known.qns);
 
     py_mark_ambiguous_callable_bindings(reg, arena);
     cbm_registry_build_type_qn_order(reg, arena);

plugin/.claude-plugin/plugin.json

@@ -0,0 +1,9 @@
+{
+  "name": "codebase-memory",
+  "version": "0.12.1",
+  "description": "Codebase knowledge graph for AI agents: sub-ms queries, 99% fewer tokens.",
+  "author": {
+    "name": "DeusData",
+    "url": "https://github.com/DeusData"
+  }
+}

plugin/.mcp.json

@@ -0,0 +1,9 @@
+{
+  "mcpServers": {
+    "codebase-memory-mcp": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "codebase-memory-mcp@0.12.1"]
+    }
+  }
+}

src/cli/cli.c

@@ -20,6 +20,7 @@
 #include "daemon/runtime.h"
 #include "daemon/version_cohort.h"
 #include "foundation/compat.h"
+#include "foundation/compat_fs.h"
 #include "foundation/platform.h"
 #include "foundation/constants.h"
 #include "foundation/json_writer.h"
@@ -2718,12 +2719,8 @@ int cbm_remove_zed_mcp_owned(const char *binary_path, const char *config_path) {
 /* ── Agent detection ──────────────────────────────────────────── */
 
 static bool dir_exists(const char *path) {
-    struct stat st;
-#ifndef _WIN32
-    return lstat(path, &st) == 0 && S_ISDIR(st.st_mode);
-#else
-    return stat(path, &st) == 0 && S_ISDIR(st.st_mode);
-#endif
+    cbm_path_info_t info = {0};
+    return cbm_path_info_utf8(path, &info) == CBM_PATH_INFO_OK && info.is_directory;
 }
 
 /* Resolve the Claude Code config dir.

src/discover/discover.h

@@ -65,8 +65,9 @@ CBMLanguage cbm_disambiguate_res(const char *path);
 CBMLanguage cbm_disambiguate_d(const char *path);
 
 /* Disambiguate .inc files by reading first 4KB of content.
- * Returns CBM_LANG_OBJECTSCRIPT_ROUTINE if it looks like an ObjectScript
- * include (a "ROUTINE <Uppercase>" header), otherwise CBM_LANG_BITBAKE.
+ * Returns CBM_LANG_CPP for explicit C-family code, or
+ * CBM_LANG_OBJECTSCRIPT_ROUTINE for ObjectScript markers / a lone #define.
+ * BitBake recipe syntax and unknown content retain CBM_LANG_BITBAKE.
  * On read failure, defaults to CBM_LANG_BITBAKE. */
 CBMLanguage cbm_disambiguate_inc(const char *path);