Add Go LSP hybrid type resolver, config store, and supporting infrastructure

- Go LSP cross-file type resolution engine (internal/cbm/lsp/) with C-based
  type registry, scope tracking, and Go stdlib data (30K+ definitions)
- lsp_bridge.go: CrossFileDef struct and RunGoLSPCrossFile CGo bridge
- config.go: persistent ConfigStore (SQLite) for auto_index, mem_limit settings
- CLI config subcommand for get/set/list/delete operations
- Store: edge batch upsert, project config columns, goleak test harness
- Pipeline: prefetch parallelism, resolver improvements, memleak tests
- CI: dry-run workflow improvements, vendor-grammar.sh enhancements

Author: DeusData

.github/workflows/dry-run.yml

@@ -58,6 +58,25 @@ jobs:
       - name: Smoke test
         run: bash scripts/smoke-test.sh ./codebase-memory-mcp
 
+  test-asan:
+    needs: [lint]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-go@v5
+        with:
+          go-version: "1.26"
+
+      - name: Test with AddressSanitizer
+        env:
+          CGO_CFLAGS: "-fsanitize=address -fno-omit-frame-pointer"
+          CGO_LDFLAGS: "-fsanitize=address"
+        run: go test -count=1 -timeout=10m ./...
+
+      - name: Memory stability check
+        run: go test -run TestMemoryStability -v -count=1 -timeout=5m ./internal/pipeline/
+
   test-windows:
     needs: [lint]
     runs-on: windows-latest

.gitignore

@@ -32,3 +32,4 @@ Thumbs.db
 
 # Local project memory (Claude Code auto-memory)
 memory/
+reference/

Makefile

@@ -1,4 +1,4 @@
-.PHONY: build test lint clean install check
+.PHONY: build test lint clean install check bench-memory
 
 BINARY=codebase-memory-mcp
 MODULE=github.com/DeusData/codebase-memory-mcp
@@ -19,3 +19,6 @@ clean:
 
 install:
 	go install ./cmd/codebase-memory-mcp/
+
+bench-memory:  ## Run memory stability benchmark
+	go test -run TestMemoryStability -v -count=1 -timeout=5m ./internal/pipeline/

cmd/codebase-memory-mcp/config.go

@@ -0,0 +1,237 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"sort"
+	"strings"
+
+	"github.com/DeusData/codebase-memory-mcp/internal/store"
+)
+
+// configDefaults documents all known config keys, their defaults, and descriptions.
+var configDefaults = []struct {
+	Key         string
+	Default     string
+	Description string
+}{
+	{store.ConfigAutoIndex, "false", "Enable background auto-indexing on MCP session start"},
+	{store.ConfigAutoIndexLimit, "50000", "Max files for auto-indexing new (never-indexed) projects"},
+	{store.ConfigMemLimit, "", "GOMEMLIMIT for the server process (e.g. 2G, 512M). Empty = no limit"},
+}
+
+func runConfig(args []string) int {
+	if len(args) == 0 {
+		printConfigHelp()
+		return 0
+	}
+
+	switch args[0] {
+	case "list", "ls":
+		return configList()
+	case "get":
+		if len(args) < 2 {
+			fmt.Fprintln(os.Stderr, "Usage: codebase-memory-mcp config get <key>")
+			return 1
+		}
+		return configGet(args[1])
+	case "set":
+		if len(args) < 3 {
+			fmt.Fprintln(os.Stderr, "Usage: codebase-memory-mcp config set <key> <value>")
+			return 1
+		}
+		return configSet(args[1], args[2])
+	case "reset":
+		if len(args) < 2 {
+			fmt.Fprintln(os.Stderr, "Usage: codebase-memory-mcp config reset <key>")
+			return 1
+		}
+		return configReset(args[1])
+	case "--help", "-h", "help":
+		printConfigHelp()
+		return 0
+	default:
+		fmt.Fprintf(os.Stderr, "Unknown config command: %s\n", args[0])
+		printConfigHelp()
+		return 1
+	}
+}
+
+func configList() int {
+	cfg, err := store.OpenConfig()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "error: %v\n", err)
+		return 1
+	}
+	defer cfg.Close()
+
+	all, err := cfg.All()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "error: %v\n", err)
+		return 1
+	}
+
+	// Merge with defaults to show all known keys
+	merged := make(map[string]string)
+	for _, d := range configDefaults {
+		merged[d.Key] = d.Default
+	}
+	for k, v := range all {
+		merged[k] = v
+	}
+
+	keys := make([]string, 0, len(merged))
+	for k := range merged {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+
+	fmt.Println("Configuration:")
+	for _, k := range keys {
+		v := merged[k]
+		source := "default"
+		if _, ok := all[k]; ok {
+			source = "set"
+		}
+		desc := configDescription(k)
+		fmt.Printf("  %-25s = %-10s  (%s) %s\n", k, v, source, desc)
+	}
+	return 0
+}
+
+func configGet(key string) int {
+	cfg, err := store.OpenConfig()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "error: %v\n", err)
+		return 1
+	}
+	defer cfg.Close()
+
+	defVal := configDefaultValue(key)
+	val := cfg.Get(key, defVal)
+	fmt.Println(val)
+	return 0
+}
+
+func configSet(key, value string) int {
+	// Validate known keys
+	if !isKnownConfigKey(key) {
+		fmt.Fprintf(os.Stderr, "Unknown config key: %s\n", key)
+		fmt.Fprintf(os.Stderr, "Known keys: %s\n", knownConfigKeys())
+		return 1
+	}
+
+	// Validate mem_limit
+	if key == store.ConfigMemLimit && value != "" {
+		if _, err := parseByteSize(value); err != nil {
+			fmt.Fprintf(os.Stderr, "Invalid value for %s: %q (expected size like 2G, 512M, 4096M)\n", key, value)
+			return 1
+		}
+	}
+
+	// Validate bool keys
+	if key == store.ConfigAutoIndex {
+		v := strings.ToLower(value)
+		if v != "true" && v != "false" && v != "on" && v != "off" && v != "1" && v != "0" {
+			fmt.Fprintf(os.Stderr, "Invalid value for %s: %q (expected true/false)\n", key, value)
+			return 1
+		}
+		// Normalize
+		switch v {
+		case "on", "1":
+			value = "true"
+		case "off", "0":
+			value = "false"
+		default:
+			value = v
+		}
+	}
+
+	cfg, err := store.OpenConfig()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "error: %v\n", err)
+		return 1
+	}
+	defer cfg.Close()
+
+	if err := cfg.Set(key, value); err != nil {
+		fmt.Fprintf(os.Stderr, "error: %v\n", err)
+		return 1
+	}
+	fmt.Printf("%s = %s\n", key, value)
+	return 0
+}
+
+func configReset(key string) int {
+	cfg, err := store.OpenConfig()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "error: %v\n", err)
+		return 1
+	}
+	defer cfg.Close()
+
+	if err := cfg.Delete(key); err != nil {
+		fmt.Fprintf(os.Stderr, "error: %v\n", err)
+		return 1
+	}
+	fmt.Printf("%s reset to default (%s)\n", key, configDefaultValue(key))
+	return 0
+}
+
+func printConfigHelp() {
+	fmt.Fprintf(os.Stderr, `Usage: codebase-memory-mcp config <command> [args]
+
+Commands:
+  list             Show all config values (with defaults)
+  get <key>        Get a config value
+  set <key> <val>  Set a config value
+  reset <key>      Reset a key to its default
+
+Config keys:
+`)
+	for _, d := range configDefaults {
+		fmt.Fprintf(os.Stderr, "  %-25s  default=%-10s  %s\n", d.Key, d.Default, d.Description)
+	}
+	fmt.Fprintf(os.Stderr, `
+Examples:
+  codebase-memory-mcp config set auto_index true     Enable auto-indexing on session start
+  codebase-memory-mcp config set auto_index false    Disable auto-indexing (default)
+  codebase-memory-mcp config set auto_index_limit 20000
+  codebase-memory-mcp config list                    Show all settings
+`)
+}
+
+func configDefaultValue(key string) string {
+	for _, d := range configDefaults {
+		if d.Key == key {
+			return d.Default
+		}
+	}
+	return ""
+}
+
+func configDescription(key string) string {
+	for _, d := range configDefaults {
+		if d.Key == key {
+			return d.Description
+		}
+	}
+	return ""
+}
+
+func isKnownConfigKey(key string) bool {
+	for _, d := range configDefaults {
+		if d.Key == key {
+			return true
+		}
+	}
+	return false
+}
+
+func knownConfigKeys() string {
+	keys := make([]string, len(configDefaults))
+	for i, d := range configDefaults {
+		keys[i] = d.Key
+	}
+	return strings.Join(keys, ", ")
+}

internal/cbm/cbm.c

@@ -2,6 +2,7 @@
 #include "helpers.h"
 #include "lang_specs.h"
 #include "extract_unified.h"
+#include "lsp/go_lsp.h"
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
@@ -98,6 +99,11 @@ void cbm_impltrait_push(CBMImplTraitArray* arr, CBMArena* a, CBMImplTrait it) {
     arr->items[arr->count++] = it;
 }
 
+void cbm_resolvedcall_push(CBMResolvedCallArray* arr, CBMArena* a, CBMResolvedCall rc) {
+    GROW_ARRAY(arr, a, CBMResolvedCall);
+    arr->items[arr->count++] = rc;
+}
+
 // --- String input reader (for parse_with_options) ---
 
 typedef struct {
@@ -261,6 +267,11 @@ CBMFileResult* cbm_extract_file(
     cbm_extract_imports(&ctx);
     cbm_extract_unified(&ctx);
 
+    // LSP type-aware call resolution (Go only for now)
+    if (language == CBM_LANG_GO) {
+        cbm_run_go_lsp(a, result, source, source_len, root);
+    }
+
     uint64_t t2 = now_ns();
 
     result->imports_count = result->imports.count;

internal/cbm/cbm.go

@@ -16,18 +16,28 @@ import (
 	"github.com/DeusData/codebase-memory-mcp/internal/lang"
 )
 
+// ResolvedCall represents a high-confidence type-aware call resolution from LSP.
+type ResolvedCall struct {
+	CallerQN   string
+	CalleeQN   string
+	Strategy   string
+	Confidence float32
+	Reason     string // diagnostic label for unresolved calls (empty if resolved)
+}
+
 // FileResult holds the extraction results from one file.
 type FileResult struct {
-	Definitions []Definition
-	Calls       []Call
-	Imports     []Import
-	Usages      []Usage
-	Throws      []Throw
-	ReadWrites  []ReadWrite
-	TypeRefs    []TypeRef
-	EnvAccesses []EnvAccess
-	TypeAssigns []TypeAssign
-	ImplTraits  []ImplTrait
+	Definitions   []Definition
+	Calls         []Call
+	Imports       []Import
+	Usages        []Usage
+	Throws        []Throw
+	ReadWrites    []ReadWrite
+	TypeRefs      []TypeRef
+	EnvAccesses   []EnvAccess
+	TypeAssigns   []TypeAssign
+	ImplTraits    []ImplTrait
+	ResolvedCalls []ResolvedCall
 
 	ModuleQN    string
 	IsTestFile  bool
@@ -55,7 +65,9 @@ type Definition struct {
 	ParentClass   string
 	Decorators    []string
 	BaseClasses   []string
+	ParamNames    []string
 	ParamTypes    []string
+	ReturnTypes   []string
 	Complexity    int
 	Lines         int
 	IsExported    bool
@@ -279,7 +291,9 @@ func convertResult(r *C.CBMFileResult) *FileResult {
 				ParentClass:   goStringOrEmpty(d.parent_class),
 				Decorators:    goStringSlice(d.decorators),
 				BaseClasses:   goStringSlice(d.base_classes),
-				ParamTypes:    goStringSlice(d.param_types),
+				ParamNames:    goStringSlice(d.param_names),
+			ParamTypes:    goStringSlice(d.param_types),
+			ReturnTypes:   goStringSlice(d.return_types),
 				Complexity:    int(d.complexity),
 				Lines:         int(d.lines),
 				IsExported:    bool(d.is_exported),
@@ -400,6 +414,21 @@ func convertResult(r *C.CBMFileResult) *FileResult {
 		}
 	}
 
+	// ResolvedCalls (LSP)
+	if r.resolved_calls.count > 0 {
+		fr.ResolvedCalls = make([]ResolvedCall, r.resolved_calls.count)
+		rcs := unsafe.Slice(r.resolved_calls.items, r.resolved_calls.count)
+		for i, rc := range rcs {
+			fr.ResolvedCalls[i] = ResolvedCall{
+				CallerQN:   C.GoString(rc.caller_qn),
+				CalleeQN:   C.GoString(rc.callee_qn),
+				Strategy:   C.GoString(rc.strategy),
+				Confidence: float32(rc.confidence),
+				Reason:     goStringOrEmpty(rc.reason),
+			}
+		}
+	}
+
 	return fr
 }