codecortex 0.8.0__tar.gz → 0.8.1__tar.gz

{codecortex-0.8.0/src/codecortex.egg-info → codecortex-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.8.0
+Version: 0.8.1
 Summary: Local-first, MCP-native code-intelligence server — graph, LSP, and semantic search behind one safe code.query tool for coding agents.
 Author: Shammai Hamilton
 License-Expression: MIT

{codecortex-0.8.0 → codecortex-0.8.1/src/codecortex.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.8.0
+Version: 0.8.1
 Summary: Local-first, MCP-native code-intelligence server — graph, LSP, and semantic search behind one safe code.query tool for coding agents.
 Author: Shammai Hamilton
 License-Expression: MIT

codecortex-0.8.1/src/codeintel/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.8.1"

{codecortex-0.8.0 → codecortex-0.8.1}/src/codeintel/__main__.py

@@ -166,8 +166,12 @@ def main() -> None:
         gen = MapGenerator(provider)
         try:
             content = gen.generate(project_root, budget_bytes=args.budget)
-            path = gen.write(project_root, content)
-            print(f"Wrote {path} ({len(content.encode())} bytes)")
+            path, wrote = gen.write(project_root, content)
+            if wrote:
+                print(f"Wrote {path} ({len(content.encode())} bytes)")
+            else:
+                print(f"Kept existing {path} — new map was a stub (graph empty/unindexed; "
+                      f"run `codeintel index` first)")
             if args.inject:
                 inj_path, inj_action = Injector().inject(project_root)
                 if inj_path:

{codecortex-0.8.0 → codecortex-0.8.1}/src/codeintel/mapper.py

@@ -1,11 +1,30 @@
 from __future__ import annotations
 
+import logging
 import os
 from typing import Optional, TYPE_CHECKING
 
 if TYPE_CHECKING:
     from codeintel.providers.graph import GraphProvider
 
+logger = logging.getLogger(__name__)
+
+# A map with any of these sections carries real, indexed orientation content. Anything without
+# them is a degraded stub: `_minimal_map` (graph unavailable / repo unindexed / generation failed),
+# or a render over an empty graph. Note the ranked marker includes "(by caller count)" — the
+# empty-graph render emits a differently-worded "## Ranked Symbols" heading that is NOT this.
+_POPULATED_MARKERS = (
+    "## Architecture Overview",
+    "## Ranked Symbols (by caller count)",
+    "## Entry Points",
+)
+
+
+def _is_populated_map(text: str) -> bool:
+    """True when the map has real content (architecture overview, a ranked-symbol table, or entry
+    points) rather than a degraded stub — used to avoid overwriting a good CODE_INTEL.md."""
+    return any(marker in text for marker in _POPULATED_MARKERS)
+
 # Real codebase-memory-mcp contract (verified live): query_graph returns {columns, rows}
 # value-arrays, module-level calls are USAGE (not only CALLS), and nodes carry `is_entry_point`
 # (there is no `fn.type` property — that filter matched nothing, so the old queries were dead).
@@ -82,15 +101,38 @@ class MapGenerator:
         except Exception as exc:
             return _minimal_map(project_root, note=f"map generation failed: {exc}")
 
-    def write(self, project_root: str, content: str) -> str:
+    def write(self, project_root: str, content: str) -> tuple[str, bool]:
+        """Write CODE_INTEL.md; return ``(path, wrote)``. ``wrote`` is False when an existing
+        populated map was preserved rather than clobbered by a stub (or the write failed), so
+        callers can report the outcome honestly.
+
+        Don't clobber a good map with a degraded stub: `generate` returns a stub when the graph
+        backend is unavailable or hasn't indexed this repo yet — a common transient during
+        `codeintel index`'s best-effort refresh. Overwriting a previously-populated CODE_INTEL.md
+        with that stub silently destroys real orientation content, so when the new content is a
+        stub and an existing map is populated, preserve the existing file."""
         path = os.path.join(project_root, "CODE_INTEL.md")
+        if not _is_populated_map(content):
+            try:
+                if os.path.isfile(path):
+                    with open(path, encoding="utf-8") as f:
+                        existing = f.read()
+                    if _is_populated_map(existing):
+                        logger.warning(
+                            "CODE_INTEL.md: new map is a stub (graph empty/unavailable) — keeping "
+                            "the existing populated map at %s (run `codeintel index` to refresh)",
+                            path,
+                        )
+                        return path, False
+            except Exception:
+                pass  # can't read the existing file — fall through and write (best-effort)
         try:
             with open(path, "w", encoding="utf-8") as f:
                 f.write(content)
+            return path, True
         except Exception as exc:
-            import logging
-            logging.getLogger(__name__).warning("CODE_INTEL.md write failed: %s", exc)
-        return path
+            logger.warning("CODE_INTEL.md write failed: %s", exc)
+            return path, False
 
 
 def _query_ranked_symbols(provider: GraphProvider, project: str) -> list[dict]:

{codecortex-0.8.0 → codecortex-0.8.1}/src/codeintel/server.py

@@ -195,15 +195,17 @@ def code_map_handler(args: dict) -> dict:
 
         gen = MapGenerator(provider)
         content = gen.generate(project_root, budget_bytes=budget)
-        path = gen.write(project_root, content)
-        size = len(content.encode("utf-8"))
+        path, wrote = gen.write(project_root, content)
+        # size_bytes = bytes actually written; 0 when an existing populated map was preserved
+        # (the new content was a stub) — `wrote` disambiguates for the caller.
+        size = len(content.encode("utf-8")) if wrote else 0
 
         inject_result = None
         if inject:
             inj_path, inj_action = Injector().inject(project_root)
             inject_result = {"path": inj_path, "action": inj_action}
 
-        return {"ok": True, "path": path, "size_bytes": size, "inject": inject_result}
+        return {"ok": True, "path": path, "size_bytes": size, "wrote": wrote, "inject": inject_result}
     except Exception:
         return {"ok": True, "path": None, "size_bytes": 0, "note": "map-error"}
 

{codecortex-0.8.0 → codecortex-0.8.1}/tests/test_mapper.py

@@ -6,9 +6,15 @@ from unittest.mock import MagicMock
 
 import pytest
 
-from codeintel.mapper import MapGenerator
+from codeintel.mapper import MapGenerator, _minimal_map, _is_populated_map
 from codeintel.injector import Injector
 
+_POPULATED = (
+    "# CODE_INTEL.md — repo\n\n"
+    "## Ranked Symbols (by caller count)\n"
+    "| Symbol | File | Callers |\n|--------|------|---------|\n| `foo` | a.py | 9 |\n"
+)
+
 
 def _make_provider(ranked=None, entry=None, arch=None):
     """Return a mocked GraphProvider with configurable return values."""
@@ -117,13 +123,61 @@ def test_generate_reads_columns_rows_shape():
 def test_write_creates_file():
     gen = MapGenerator(None)
     with tempfile.TemporaryDirectory() as d:
-        path = gen.write(d, "# content")
+        path, wrote = gen.write(d, "# content")
         expected = os.path.join(d, "CODE_INTEL.md")
-        assert path == expected
+        assert path == expected and wrote is True
         assert os.path.exists(expected)
         assert open(expected).read() == "# content"
 
 
+def test_write_preserves_populated_map_when_new_is_a_stub():
+    # the dogfooding bug: `codeintel index`'s best-effort refresh produced a stub (graph empty/
+    # unindexed at that moment) and clobbered a rich, populated CODE_INTEL.md. It must NOT.
+    gen = MapGenerator(None)
+    with tempfile.TemporaryDirectory() as d:
+        path = os.path.join(d, "CODE_INTEL.md")
+        open(path, "w").write(_POPULATED)
+        stub = _minimal_map(d, note="project not yet indexed")
+        assert not _is_populated_map(stub) and _is_populated_map(_POPULATED)  # sanity
+        p, wrote = gen.write(d, stub)
+        assert p == path and wrote is False          # preserved → reported as not written
+        assert open(path).read() == _POPULATED        # preserved, not stubbed
+
+
+def test_write_stub_ok_when_no_existing_map():
+    # first-ever generation of a stub is fine — there's nothing to preserve
+    gen = MapGenerator(None)
+    with tempfile.TemporaryDirectory() as d:
+        _, wrote = gen.write(d, _minimal_map(d, note="x"))
+        assert wrote is True
+        assert "Auto-generated" in open(os.path.join(d, "CODE_INTEL.md")).read()
+
+
+def test_write_populated_replaces_a_stub():
+    # a real map SHOULD replace a prior stub — the normal refresh-improves case still works
+    gen = MapGenerator(None)
+    with tempfile.TemporaryDirectory() as d:
+        path = os.path.join(d, "CODE_INTEL.md")
+        open(path, "w").write(_minimal_map(d, note="stale"))
+        _, wrote = gen.write(d, _POPULATED)
+        assert wrote is True
+        assert _is_populated_map(open(path).read())
+
+
+def test_entry_points_only_map_counts_as_populated():
+    # a sparse-but-real render (entry points, no arch/ranked table) is NOT a stub — it must refresh,
+    # not be misclassified and skipped (regression for the review's false-negative finding)
+    entry_only = ("# CODE_INTEL.md — repo\n\n## Ranked Symbols\n_(no symbols found)_\n\n"
+                  "## Entry Points\n- `main` (app.py)\n")
+    assert _is_populated_map(entry_only)
+    gen = MapGenerator(None)
+    with tempfile.TemporaryDirectory() as d:
+        path = os.path.join(d, "CODE_INTEL.md")
+        open(path, "w").write(_POPULATED)
+        _, wrote = gen.write(d, entry_only)   # real content replaces the old map, not skipped
+        assert wrote is True and "Entry Points" in open(path).read()
+
+
 # ---------------------------------------------------------------------------
 # Injector tests
 # ---------------------------------------------------------------------------

codecortex-0.8.0/src/codeintel/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.8.0"