codespine 0.7.2__tar.gz → 0.8.0__tar.gz

{codespine-0.7.2 → codespine-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codespine
-Version: 0.7.2
+Version: 0.8.0
 Summary: Local Java code intelligence indexer backed by a graph database
 Author: CodeSpine contributors
 License: MIT License
@@ -267,7 +267,7 @@ codespine guide --json   # structured JSON for tooling
 | `detect_dead_code(limit, project, strict)` | Methods with no callers (Java-aware exemptions). |
 | `trace_execution_flows(entry_symbol, max_depth, project)` | Execution paths from entry points. |
 | `get_symbol_community(symbol)` | Architectural community cluster for a symbol. |
-| `get_change_coupling(months, min_strength, min_cochanges)` | Files that historically change together. |
+| `get_change_coupling(days, min_strength, min_cochanges)` | Files that changed together in the last N days (default 5). |
 
 **Git**
 

{codespine-0.7.2 → codespine-0.8.0}/README.md

@@ -203,7 +203,7 @@ codespine guide --json   # structured JSON for tooling
 | `detect_dead_code(limit, project, strict)` | Methods with no callers (Java-aware exemptions). |
 | `trace_execution_flows(entry_symbol, max_depth, project)` | Execution paths from entry points. |
 | `get_symbol_community(symbol)` | Architectural community cluster for a symbol. |
-| `get_change_coupling(months, min_strength, min_cochanges)` | Files that historically change together. |
+| `get_change_coupling(days, min_strength, min_cochanges)` | Files that changed together in the last N days (default 5). |
 
 **Git**
 

{codespine-0.7.2 → codespine-0.8.0}/codespine/__init__.py

@@ -1,4 +1,4 @@
 """CodeSpine package."""
 
 __all__ = ["__version__"]
-__version__ = "0.7.2"
+__version__ = "0.8.0"

{codespine-0.7.2 → codespine-0.8.0}/codespine/analysis/crossmodule.py

@@ -17,11 +17,10 @@ Two linking strategies are applied:
       parameter count as a method M_dst in the referenced class.  This catches
       delegation, interface-implementation forwarding, and adapter patterns.
 
-  Strategy B — Type-reference fallback  (confidence 0.4)
-      For every *public, non-constructor* method in the referenced class that
-      received NO name-match edge, create ONE low-confidence edge from the
-      referencing method.  This prevents methods that are genuinely used
-      cross-module from appearing as dead code.
+  Strategy B — Direct parameter/return type reference  (confidence 0.6)
+      When the referenced class name appears directly as a parameter type or
+      return type of the source method, create an edge to the class's
+      constructor (if any).  This catches model/DTO/context instantiation.
 """
 from __future__ import annotations
 
@@ -165,29 +164,28 @@ def link_cross_module_calls(store, project_ids: list[str] | None = None, progres
                                         LOGGER.debug("Name-match edge failed: %s", exc)
                                 matched_dst_mids.add(dm["mid"])
 
-                    # Strategy B: fallback for unmatched public dst methods
-                    for dm in dst_methods:
-                        if dm["mid"] in matched_dst_mids:
-                            continue
-                        if dm.get("is_ctor"):
-                            continue
-                        mods = dm.get("modifiers") or []
-                        mod_strs = {str(m).strip() for m in mods} if mods else set()
-                        if "private" in mod_strs:
-                            continue
-
-                        pair = (sm["mid"], dm["mid"])
-                        if pair in seen:
-                            continue
-                        seen.add(pair)
-                        try:
-                            store.add_call(
-                                sm["mid"], dm["mid"],
-                                0.4, "cross_module_type_ref",
-                            )
-                            new_edges += 1
-                        except Exception as exc:
-                            LOGGER.debug("Fallback edge failed: %s", exc)
+                    # Strategy B: if the referenced class name appears directly
+                    # in the source method's parameter types or return type,
+                    # link to the class's constructor (model/DTO instantiation).
+                    if not matched_dst_mids:
+                        rtype_tokens = set(_TOKEN_RE.findall(rtype))
+                        sig_tokens = set(_TOKEN_RE.findall(sig))
+                        if class_name in rtype_tokens or class_name in sig_tokens:
+                            for dm in dst_methods:
+                                if not dm.get("is_ctor"):
+                                    continue
+                                pair = (sm["mid"], dm["mid"])
+                                if pair in seen:
+                                    continue
+                                seen.add(pair)
+                                try:
+                                    store.add_call(
+                                        sm["mid"], dm["mid"],
+                                        0.6, "cross_module_ctor_ref",
+                                    )
+                                    new_edges += 1
+                                except Exception as exc:
+                                    LOGGER.debug("Ctor-ref edge failed: %s", exc)
 
     _ping(f"{new_edges} edges created")
     LOGGER.info("Cross-module linking: created %d new call edges.", new_edges)

{codespine-0.7.2 → codespine-0.8.0}/codespine/db/schema.py

@@ -49,7 +49,7 @@ REL_TABLES: Iterable[tuple[str, str]] = [
     ("IN_FLOW", "CREATE REL TABLE IN_FLOW(FROM Symbol TO Flow, depth INT64)"),
     (
         "CO_CHANGED_WITH",
-        "CREATE REL TABLE CO_CHANGED_WITH(FROM File TO File, strength DOUBLE, cochanges INT64, months INT64)",
+        "CREATE REL TABLE CO_CHANGED_WITH(FROM File TO File, strength DOUBLE, cochanges INT64, days INT64)",
     ),
 ]
 
@@ -86,3 +86,8 @@ def ensure_schema(conn) -> None:
 
     _safe_execute(conn, "ALTER TABLE Project ADD indexed_commit STRING DEFAULT ''")
     _safe_execute(conn, "ALTER TABLE Project ADD overlay_dirty BOOL DEFAULT false")
+
+    # v0.7.3: renamed CO_CHANGED_WITH.months → days (days-based window).
+    # ALTER TABLE is a no-op on fresh DBs that already have 'days'; safe_execute
+    # swallows the error if the column already exists or the table doesn't yet.
+    _safe_execute(conn, "ALTER TABLE CO_CHANGED_WITH ADD days INT64 DEFAULT 0")

{codespine-0.7.2 → codespine-0.8.0}/codespine/indexer/call_resolver.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from collections import defaultdict
 from typing import Iterator
 
-from codespine.noise.blocklist import NOISE_METHOD_NAMES
+from codespine.noise.blocklist import MIN_FUZZY_NAME_LEN, NOISE_METHOD_NAMES
 
 MAX_FUZZY_TARGETS = 12
 
@@ -84,8 +84,6 @@ def resolve_calls(
 
         for call in call_sites:
             call_name = call.name
-            if call_name in NOISE_METHOD_NAMES:
-                continue
 
             key = (call_name, int(call.arg_count))
             targets: list[str] = []
@@ -123,6 +121,12 @@ def resolve_calls(
                     reason = "intra_class_exact"
 
             if not targets:
+                # Skip noise method names and short names in the fuzzy global
+                # fallback — they are too ambiguous without receiver context.
+                if call_name in NOISE_METHOD_NAMES:
+                    continue
+                if len(call_name) < MIN_FUZZY_NAME_LEN:
+                    continue
                 # Prefer same-package candidates before global fallback.
                 src_pkg = src_ctx.get("package", "")
                 same_pkg = []

{codespine-0.7.2 → codespine-0.8.0}/codespine/indexer/engine.py

@@ -153,7 +153,20 @@ class JavaIndexer:
     ) -> IndexResult:
         root_path = os.path.abspath(root_path)
         if project_id is None:
-            project_id = os.path.basename(root_path)
+            # Reuse the existing project ID for this path if one exists.
+            # This prevents ID drift when the same module is re-indexed
+            # directly (vision-server) vs from a workspace root (vision::vision-server).
+            try:
+                existing = self.store.query_records(
+                    "MATCH (p:Project) WHERE p.path = $path RETURN p.id as id LIMIT 1",
+                    {"path": root_path},
+                )
+                if existing:
+                    project_id = existing[0]["id"]
+            except Exception:
+                pass
+            if project_id is None:
+                project_id = os.path.basename(root_path)
         current_files = self._collect_java_files(root_path)
         self._emit(progress, "scan_done", files_found=len(current_files))
         db_files = self.store.project_file_hashes(project_id) if not full else {}
@@ -337,6 +350,21 @@ class JavaIndexer:
                     )
                     classes_indexed += 1
 
+                    for fld in cls.fields:
+                        fqfield = f"{cls.fqcn}#{fld.name}"
+                        symbol_rows.append(
+                            {
+                                "id": symbol_id("field", fqfield, scope),
+                                "kind": "field",
+                                "name": fld.name,
+                                "fqname": fqfield,
+                                "file_id": f_id,
+                                "line": fld.line,
+                                "col": fld.col,
+                                "embedding": embed_text(f"field {fqfield} {fld.type_name}") if embed else None,
+                            }
+                        )
+
                     for method in cls.methods:
                         m_id = method_id(cls.fqcn, method.signature, scope)
                         method_rows.append(

{codespine-0.7.2 → codespine-0.8.0}/codespine/indexer/java_parser.py

@@ -35,6 +35,14 @@ class ParsedCall:
     col: int
 
 
+@dataclass
+class ParsedField:
+    name: str
+    type_name: str
+    line: int
+    col: int
+
+
 @dataclass
 class ParsedClass:
     name: str
@@ -49,6 +57,7 @@ class ParsedClass:
     field_types: dict[str, str] = field(default_factory=dict)
     body_hash: str = ""
     methods: list[ParsedMethod] = field(default_factory=list)
+    fields: list[ParsedField] = field(default_factory=list)
 
 
 @dataclass
@@ -193,7 +202,7 @@ def _extract_local_types(method_node) -> dict[str, str]:
     return locals_map
 
 
-def _extract_field_types(class_node) -> dict[str, str]:
+def _extract_field_types(class_node) -> tuple[dict[str, str], list[ParsedField]]:
     q = Query(
         JAVA_LANGUAGE,
         """
@@ -204,13 +213,21 @@ def _extract_field_types(class_node) -> dict[str, str]:
     )
     captures = _captures(q, class_node)
     field_map: dict[str, str] = {}
+    field_list: list[ParsedField] = []
     current_type = None
     for node, tag in captures:
         if tag == "type":
             current_type = _node_type_name(node)
         elif tag == "name" and current_type:
-            field_map[_text(node)] = current_type
-    return field_map
+            name = _text(node)
+            field_map[name] = current_type
+            field_list.append(ParsedField(
+                name=name,
+                type_name=current_type,
+                line=node.start_point[0] + 1,
+                col=node.start_point[1] + 1,
+            ))
+    return field_map, field_list
 
 
 def _extract_parameter_types(params_node) -> list[str]:
@@ -338,6 +355,7 @@ def parse_java_source(source: bytes) -> ParsedFile:
         fqcn = f"{package_name}.{cls_name}" if package_name else cls_name
         cls_modifiers, cls_annotations = _extract_modifiers_and_annotations(node)
         extends_name, interface_names = _extract_inheritance(node)
+        ft_map, ft_list = _extract_field_types(node)
         parsed_class = ParsedClass(
             name=cls_name,
             package=package_name,
@@ -348,8 +366,9 @@ def parse_java_source(source: bytes) -> ParsedFile:
             annotations=cls_annotations,
             extends=extends_name,
             interfaces=interface_names,
-            field_types=_extract_field_types(node),
+            field_types=ft_map,
             body_hash=_hash_node(node),
+            fields=ft_list,
         )
 
         method_nodes = [n for n, t in _captures(method_query, node) if t == "method_decl"]

{codespine-0.7.2 → codespine-0.8.0}/codespine/mcp/server.py

@@ -75,6 +75,21 @@ def _no_symbols_response(note: str = "No symbols indexed. Run 'codespine analyse
     return _json({"available": False, "note": note})
 
 
+def _normalize_symbol_input(raw: str) -> str:
+    """Normalize a symbol string so that various user input formats work.
+
+    Handles:
+      - ``com.example.MyClass#myMethod(int,String)`` → ``myMethod(int,String)``
+      - ``MyClass#myMethod``                         → ``myMethod``
+      - ``myMethod(int,String)``                     → unchanged
+      - ``myMethod``                                 → unchanged
+    """
+    s = raw.strip()
+    if "#" in s:
+        s = s[s.index("#") + 1:]
+    return s
+
+
 def _parse_indexed_at(raw) -> int:
     """Robustly parse an indexed_at value that may be str, int, float, or None."""
     if raw is None:
@@ -256,8 +271,18 @@ def build_mcp_server(store, repo_path_provider):
         from codespine.search.vector import _load_model
         has_embeddings = _load_model() is not None
 
+        # Check git availability on the default path AND on each indexed
+        # project path.  Project-scoped git operations (git_log, git_diff,
+        # compare_branches) work when the project path is a git repo, even
+        # if the default path (cwd) is not.
         repo = repo_path_provider()
         git_ok = _git_available(repo)
+        if not git_ok:
+            for p in projects:
+                pp = p.get("path", "")
+                if pp and os.path.isdir(pp) and _git_available(pp):
+                    git_ok = True
+                    break
 
         n_sym = sym_q[0]["count"] if sym_q else 0
         n_comm = comm_q[0]["count"] if comm_q else 0
@@ -450,7 +475,11 @@ def build_mcp_server(store, repo_path_provider):
         Caller-tree impact analysis for a symbol.
         project scopes the target symbol lookup; cross-project callers are always included.
         """
-        result = analyze_impact(store, symbol, max_depth=max_depth, project=project)
+        normalized = _normalize_symbol_input(symbol)
+        result = analyze_impact(store, normalized, max_depth=max_depth, project=project)
+        if not result.get("targets_resolved"):
+            # Retry with the raw input in case the ID matched exactly.
+            result = analyze_impact(store, symbol, max_depth=max_depth, project=project)
         if not result.get("targets_resolved"):
             return {"available": False, "note": f"Symbol '{symbol}' not found in the index."}
         return _staleness_meta(store, {"available": True, **result}, project, overlay_store=overlay_store)
@@ -502,6 +531,8 @@ def build_mcp_server(store, repo_path_provider):
         Trace execution flows from entry points (main methods, tests).
         Pass project to scope entry-point discovery to a single module.
         """
+        if entry_symbol:
+            entry_symbol = _normalize_symbol_input(entry_symbol)
         flows = trace_flows_analysis(store, entry_symbol=entry_symbol, max_depth=max_depth, project=project)
         if not flows:
             return _no_symbols_response("No entry points found. Run 'codespine analyse --deep' or provide entry_symbol.")
@@ -514,7 +545,10 @@ def build_mcp_server(store, repo_path_provider):
         # graph DB read-only, so any write attempt raises "Cannot execute write
         # operations in a read-only database!".  Communities are computed once
         # during 'codespine analyse --deep' and persisted; we just read them.
-        result = symbol_community(store, symbol)
+        normalized = _normalize_symbol_input(symbol)
+        result = symbol_community(store, normalized)
+        if not result.get("matches"):
+            result = symbol_community(store, symbol)
         if not result.get("matches"):
             return {"available": False, "note": "No community data yet. Run 'codespine analyse --deep'."}
         return _staleness_meta(store, {"available": True, **result}, overlay_store=overlay_store, deep_scope=True)
@@ -646,7 +680,7 @@ def build_mcp_server(store, repo_path_provider):
         Parameters:
           name    – Simple class/method name, fully-qualified name, or prefix.
                     Matching is case-insensitive on the simple name; exact on the FQCN.
-          kind    – Optional filter: "class" or "method".
+          kind    – Optional filter: "class", "method", or "field".
           project – Optional project_id to restrict the search.
           limit   – Max results per kind (default 50).
 
@@ -703,7 +737,39 @@ def build_mcp_server(store, repo_path_provider):
                     if len(methods) >= limit:
                         break
 
-        total = len(classes) + len(methods)
+        fields: list[dict] = []
+        if kind in (None, "field"):
+            project_clause_f = "AND f.project_id = $proj" if project else ""
+            field_params: dict = {"namel": name_lower, "lim": limit}
+            if project:
+                field_params["proj"] = project
+            field_recs = store.query_records(
+                f"""
+                MATCH (s:Symbol), (f:File)
+                WHERE s.file_id = f.id AND s.kind = 'field'
+                  AND (lower(s.name) = $namel OR lower(s.fqname) CONTAINS $namel)
+                  {project_clause_f}
+                RETURN s.id as id, s.name as name, s.fqname as fqname,
+                       f.project_id as project_id, f.path as file_path,
+                       s.line as line, s.col as col
+                LIMIT $lim
+                """,
+                field_params,
+            )
+            for rec in field_recs:
+                fields.append(
+                    {
+                        "id": rec.get("id"),
+                        "name": rec.get("name"),
+                        "fqname": rec.get("fqname"),
+                        "project_id": rec.get("project_id"),
+                        "file_path": rec.get("file_path"),
+                        "line": rec.get("line"),
+                        "col": rec.get("col"),
+                    }
+                )
+
+        total = len(classes) + len(methods) + len(fields)
         if total == 0:
             return {
                 "available": False,
@@ -714,12 +780,16 @@ def build_mcp_server(store, repo_path_provider):
         by_project: dict[str, dict] = {}
         for c in classes:
             pid = c.get("project_id", "?")
-            by_project.setdefault(pid, {"classes": [], "methods": []})
+            by_project.setdefault(pid, {"classes": [], "methods": [], "fields": []})
             by_project[pid]["classes"].append(c)
         for m in methods:
             pid = m.get("project_id", "?")
-            by_project.setdefault(pid, {"classes": [], "methods": []})
+            by_project.setdefault(pid, {"classes": [], "methods": [], "fields": []})
             by_project[pid]["methods"].append(m)
+        for f in fields:
+            pid = f.get("project_id", "?")
+            by_project.setdefault(pid, {"classes": [], "methods": [], "fields": []})
+            by_project[pid]["fields"].append(f)
 
         return _staleness_meta(store, {
             "available": True,
@@ -1367,17 +1437,22 @@ def build_mcp_server(store, repo_path_provider):
         """
         from codespine.analysis.impact import _resolve_method_metadata
 
+        # Normalize FQN inputs: "Class#method(sig)" → "method(sig)"
+        normalized = _normalize_symbol_input(symbol)
+
         project_clause = "AND f.project_id = $proj" if project else ""
-        params: dict = {"q": symbol}
+        params: dict = {"q": normalized, "raw": symbol}
         if project:
             params["proj"] = project
 
-        # 1. Resolve the symbol to method IDs
+        # 1. Resolve the symbol to method IDs.  Try both the normalized
+        #    form and the raw input so exact-ID matches still work.
         method_recs = store.query_records(
             f"""
             MATCH (m:Method), (c:Class), (f:File)
             WHERE m.class_id = c.id AND c.file_id = f.id {project_clause}
-              AND (m.id = $q OR lower(m.name) = lower($q)
+              AND (m.id = $q OR m.id = $raw
+                   OR lower(m.name) = lower($q)
                    OR lower(m.signature) CONTAINS lower($q))
             RETURN m.id as id, m.name as name, m.signature as signature,
                    c.id as class_id, c.fqcn as class_fqcn,
@@ -1393,20 +1468,22 @@ def build_mcp_server(store, repo_path_provider):
         mid = target["id"]
         cid = target["class_id"]
 
-        # 2. Callers (upstream)
+        # 2. Callers (upstream) — exclude low-confidence cross-module fallback edges
         callers = store.query_records(
             """
             MATCH (caller:Method)-[r:CALLS]->(m:Method {id: $mid})
+            WHERE coalesce(r.confidence, 0.5) >= 0.5
             RETURN caller.id as id, coalesce(r.confidence, 0.5) as confidence,
                    coalesce(r.reason, 'unknown') as reason
             """,
             {"mid": mid},
         )
 
-        # 3. Callees (downstream)
+        # 3. Callees (downstream) — exclude low-confidence cross-module fallback edges
         callees = store.query_records(
             """
             MATCH (m:Method {id: $mid})-[r:CALLS]->(callee:Method)
+            WHERE coalesce(r.confidence, 0.5) >= 0.5
             RETURN callee.id as id, coalesce(r.confidence, 0.5) as confidence,
                    coalesce(r.reason, 'unknown') as reason
             """,

codespine-0.8.0/codespine/noise/blocklist.py

@@ -0,0 +1,33 @@
+"""Noise filters for call graph generation."""
+
+NOISE_METHOD_NAMES = {
+    # Object / lang
+    "print", "println", "printf",
+    "hashCode", "equals", "toString", "getClass",
+    "notify", "notifyAll", "wait", "clone", "finalize",
+    "compareTo",
+    # Collections / streams
+    "isEmpty", "size", "length",
+    "stream", "parallelStream", "forEach", "map", "filter", "collect",
+    "orElse", "orElseGet", "orElseThrow", "of", "ofNullable",
+    "add", "append", "remove", "contains", "put", "putAll",
+    "addAll", "removeAll", "containsAll", "containsKey", "containsValue",
+    "entrySet", "keySet", "values", "iterator", "hasNext", "next",
+    # Logging
+    "log", "debug", "info", "warn", "error", "trace",
+    # Common short helpers that create false-positive edges
+    "get", "set", "apply", "accept", "test",
+    "run", "call", "execute", "invoke",
+    "build", "create", "from", "parse", "format",
+    "close", "open", "init", "start", "stop", "reset",
+    "read", "write", "flush", "clear",
+    "supply", "compose", "andThen",
+    # Builder / accessor patterns
+    "builder", "toBuilder", "newBuilder",
+    "getName", "setName", "getValue", "setValue",
+    "getId", "setId", "getType", "setType",
+}
+
+# Minimum method name length for fuzzy (global name+arity) fallback.
+# Shorter names are too ambiguous for unresolved-receiver resolution.
+MIN_FUZZY_NAME_LEN = 4

{codespine-0.7.2 → codespine-0.8.0}/codespine/watch/watcher.py

@@ -74,9 +74,12 @@ def clear_overlay(store, project: str | None = None) -> list[str]:
     cleared: list[str] = []
     for project_id in targets:
         overlay_store.clear_project(project_id)
-        meta = store.get_project_metadata(project_id)
-        if meta:
-            store.set_project_overlay_dirty(project_id, False)
+        try:
+            meta = store.get_project_metadata(project_id)
+            if meta:
+                store.set_project_overlay_dirty(project_id, False)
+        except Exception as exc:
+            LOGGER.warning("clear_overlay: could not update DB dirty flag for %s (%s); overlay files cleared", project_id, exc)
         cleared.append(project_id)
     return cleared
 

{codespine-0.7.2 → codespine-0.8.0}/codespine.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codespine
-Version: 0.7.2
+Version: 0.8.0
 Summary: Local Java code intelligence indexer backed by a graph database
 Author: CodeSpine contributors
 License: MIT License
@@ -267,7 +267,7 @@ codespine guide --json   # structured JSON for tooling
 | `detect_dead_code(limit, project, strict)` | Methods with no callers (Java-aware exemptions). |
 | `trace_execution_flows(entry_symbol, max_depth, project)` | Execution paths from entry points. |
 | `get_symbol_community(symbol)` | Architectural community cluster for a symbol. |
-| `get_change_coupling(months, min_strength, min_cochanges)` | Files that historically change together. |
+| `get_change_coupling(days, min_strength, min_cochanges)` | Files that changed together in the last N days (default 5). |
 
 **Git**
 

{codespine-0.7.2 → codespine-0.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codespine"
-version = "0.7.2"
+version = "0.8.0"
 description = "Local Java code intelligence indexer backed by a graph database"
 readme = "README.md"
 requires-python = ">=3.10"

codespine-0.7.2/codespine/noise/blocklist.py

@@ -1,37 +0,0 @@
-"""Noise filters for call graph generation."""
-
-NOISE_METHOD_NAMES = {
-    "print",
-    "println",
-    "printf",
-    "hashCode",
-    "equals",
-    "toString",
-    "getClass",
-    "notify",
-    "notifyAll",
-    "wait",
-    "clone",
-    "finalize",
-    "compareTo",
-    "isEmpty",
-    "size",
-    "length",
-    "stream",
-    "parallelStream",
-    "forEach",
-    "map",
-    "filter",
-    "collect",
-    "orElse",
-    "orElseGet",
-    "add",
-    "append",
-    "remove",
-    "contains",
-    "log",
-    "debug",
-    "info",
-    "warn",
-    "error",
-}