codecortex 0.8.1__tar.gz → 0.8.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.8.1
+Version: 0.8.2
 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 → codecortex-0.8.2/src/codecortex.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.8.1
+Version: 0.8.2
 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 → codecortex-0.8.2}/src/codecortex.egg-info/SOURCES.txt

@@ -48,6 +48,7 @@ tests/test_graph_stdin.py
 tests/test_hardening.py
 tests/test_http_auth.py
 tests/test_http_server.py
+tests/test_installer.py
 tests/test_integration.py
 tests/test_lsp_provider.py
 tests/test_lsp_real.py

codecortex-0.8.2/src/codeintel/__init__.py

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

codecortex-0.8.2/src/codeintel/installer.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import json
+import os
+import pathlib
+
+_AGENTS = ["claude", "codex", "gemini", "zed"]
+
+
+def _atomic_write_text(path: pathlib.Path, text: str) -> None:
+    """Write via a sibling temp file + os.replace so an interrupted write can never truncate
+    the user's existing agent config (which holds unrelated settings) to a partial/empty file.
+    The temp lives in the same directory as ``path`` so the replace stays on one filesystem."""
+    tmp = path.with_name(path.name + ".codeintel.tmp")
+    tmp.write_text(text, encoding="utf-8")
+    os.replace(tmp, path)
+
+
+# Per-agent registration recipe. Most agents take a Claude-style JSON block; Codex is different —
+# its CLI reads MCP servers from ``~/.codex/config.toml`` as ``[mcp_servers.<name>]`` TOML tables,
+# NOT a JSON ``mcpServers`` map in config.json (writing the latter registers nothing).
+_CONFIG: dict[str, dict] = {
+    "claude": {
+        "format": "json",
+        "path": "~/.claude/settings.json",
+        "key": ["mcpServers", "codeintel"],
+        "value": {"command": "codeintel", "args": ["serve"]},
+    },
+    "codex": {
+        "format": "toml-mcp",
+        "path": "~/.codex/config.toml",
+        "table": "[mcp_servers.codeintel]",
+        "block": '[mcp_servers.codeintel]\ncommand = "codeintel"\nargs = ["serve"]\n',
+    },
+    "gemini": {
+        "format": "json",
+        "path": "~/.gemini/settings.json",
+        "key": ["mcpServers", "codeintel"],
+        "value": {"command": "codeintel", "args": ["serve"]},
+    },
+    "zed": {
+        "format": "json",
+        "path": "~/.config/zed/settings.json",
+        "key": ["context_servers", "codeintel"],
+        "value": {"command": {"path": "codeintel", "args": ["serve"]}},
+    },
+}
+
+
+def _get_nested(data: dict, keys: list[str]):
+    node = data
+    for k in keys:
+        if not isinstance(node, dict) or k not in node:
+            return None
+        node = node[k]
+    return node
+
+
+def _set_nested(data: dict, keys: list[str], value) -> None:
+    node = data
+    for k in keys[:-1]:
+        if k not in node or not isinstance(node[k], dict):
+            node[k] = {}
+        node = node[k]
+    node[keys[-1]] = value
+
+
+class Installer:
+    def register(self, agent: str) -> dict:
+        spec = _CONFIG.get(agent)
+        if spec is None:
+            return self._result(agent, "", False, "failed", f"unknown agent '{agent}'")
+        config_path = pathlib.Path(spec["path"]).expanduser()
+        try:
+            if spec.get("format") == "toml-mcp":
+                return self._register_toml(agent, config_path, spec)
+            return self._register_json(agent, config_path, spec)
+        except Exception as exc:
+            return self._result(agent, str(config_path), False, "failed", str(exc))
+
+    def _register_json(self, agent: str, config_path: pathlib.Path, spec: dict) -> dict:
+        if config_path.exists():
+            data = json.loads(config_path.read_text(encoding="utf-8"))
+            if not isinstance(data, dict):
+                data = {}
+        else:
+            data = {}
+
+        if _get_nested(data, spec["key"]) == spec["value"]:
+            return self._result(agent, str(config_path), True, "already")
+
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        _set_nested(data, spec["key"], spec["value"])
+        _atomic_write_text(config_path, json.dumps(data, indent=2))
+        return self._result(agent, str(config_path), True, "registered")
+
+    def _register_toml(self, agent: str, config_path: pathlib.Path, spec: dict) -> dict:
+        """Codex: append an ``[mcp_servers.codeintel]`` table to config.toml, preserving everything
+        already there (other servers, project trust levels, hooks). Text-based on purpose — it must
+        not reformat or risk corrupting a config the user hand-edits, and it stays idempotent by
+        checking for the table header. If a codeintel entry already exists it is left untouched."""
+        existing = config_path.read_text(encoding="utf-8") if config_path.exists() else ""
+        if spec["table"] in existing:
+            return self._result(agent, str(config_path), True, "already")
+
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        if existing == "":
+            new_text = spec["block"]
+        else:
+            prefix = existing if existing.endswith("\n") else existing + "\n"
+            new_text = prefix + "\n" + spec["block"]  # blank line before the new table
+        _atomic_write_text(config_path, new_text)
+        return self._result(agent, str(config_path), True, "registered")
+
+    @staticmethod
+    def _result(agent: str, path: str, ok: bool, action: str, reason: str = "") -> dict:
+        return {"agent": agent, "path": path, "ok": ok, "action": action, "reason": reason}
+
+    def register_all(self) -> list[dict]:
+        return [self.register(agent) for agent in _AGENTS]

{codecortex-0.8.1 → codecortex-0.8.2}/src/codeintel/providers/graph.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import os
 import shutil
 import subprocess
 import threading
@@ -107,6 +108,13 @@ class GraphProvider:
         older/mocked shape — accept both. Prefer an exact ``root_path`` match; otherwise the
         LONGEST prefix match (so ``.../project/codeintel`` resolves to codeintel, not its
         parent ``.../project``). Pure + static so ``_resolve_project`` and ``probe`` share it."""
+        # Normalize the input to an absolute realpath: the backend stores absolute root_paths, so a
+        # relative ``project_root`` (e.g. `codeintel map .` passing ".") would otherwise never match
+        # — the bug where the map/query silently reported "not indexed" from inside the repo.
+        try:
+            project_root = os.path.realpath(project_root)
+        except Exception:
+            pass
         entries = raw.get("projects", []) if isinstance(raw, dict) else raw
         if not isinstance(entries, list):
             return None

{codecortex-0.8.1 → codecortex-0.8.2}/tests/test_graph_provider.py

@@ -1,12 +1,25 @@
 """GraphProvider tests: never-raise invariant and key behavioral guarantees."""
 from __future__ import annotations
 
+import os
 import subprocess
 
 from codeintel.providers.graph import GraphProvider
 from codeintel.server import code_status_handler
 
 
+def test_match_project_resolves_a_relative_path(tmp_path, monkeypatch):
+    # The backend stores absolute root_paths, so a relative project_root (e.g. `codeintel map .`)
+    # must be normalized before matching — otherwise resolution fails from inside the repo and the
+    # map/graph query silently reports "not indexed" (the map-stub bug).
+    real = os.path.realpath(str(tmp_path))
+    raw = {"projects": [{"name": "myrepo", "root_path": real}]}
+    monkeypatch.chdir(tmp_path)
+    assert GraphProvider._match_project(raw, ".") == "myrepo"      # relative resolves now
+    assert GraphProvider._match_project(raw, real) == "myrepo"     # absolute still works
+    assert GraphProvider._match_project(raw, os.path.join(real, "src")) == "myrepo"  # subdir prefix
+
+
 # ---------------------------------------------------------------------------
 # Group 1 — Never-raise: None args
 # ---------------------------------------------------------------------------

codecortex-0.8.2/tests/test_installer.py

@@ -0,0 +1,97 @@
+"""Installer / agent-registration tests (added 0.8.2).
+
+The installer had no tests, which is why `--agent codex` shipped writing a Claude-style JSON
+`mcpServers` block to `~/.codex/config.json` — but Codex CLI reads MCP servers from
+`~/.codex/config.toml` as `[mcp_servers.<name>]` TOML, so nothing was actually registered.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from codeintel.installer import Installer
+
+
+def _codex_toml(home: Path) -> Path:
+    return home / ".codex" / "config.toml"
+
+
+# --------------------------------------------------------------------------- codex (TOML)
+
+def test_codex_registers_as_toml_in_config_toml(tmp_path, monkeypatch):
+    monkeypatch.setenv("HOME", str(tmp_path))
+    cfg = _codex_toml(tmp_path)
+    cfg.parent.mkdir(parents=True)
+    cfg.write_text('[mcp_servers.serena]\ncommand = "serena"\n')  # pre-existing MCP server
+
+    res = Installer().register("codex")
+
+    assert res["ok"] and res["action"] == "registered"
+    text = cfg.read_text()
+    assert "[mcp_servers.codeintel]" in text                 # written to config.toml as TOML
+    assert 'command = "codeintel"' in text and 'args = ["serve"]' in text
+    assert "[mcp_servers.serena]" in text                    # existing content preserved
+
+
+def test_codex_does_not_write_the_wrong_json_file(tmp_path, monkeypatch):
+    # regression: the old installer wrote ~/.codex/config.json (mcpServers), which Codex ignores
+    monkeypatch.setenv("HOME", str(tmp_path))
+    Installer().register("codex")
+    assert _codex_toml(tmp_path).exists()
+    assert not (tmp_path / ".codex" / "config.json").exists()
+
+
+def test_codex_creates_config_when_missing(tmp_path, monkeypatch):
+    monkeypatch.setenv("HOME", str(tmp_path))
+    res = Installer().register("codex")
+    assert res["ok"] and _codex_toml(tmp_path).read_text().startswith("[mcp_servers.codeintel]")
+
+
+def test_codex_is_idempotent(tmp_path, monkeypatch):
+    monkeypatch.setenv("HOME", str(tmp_path))
+    assert Installer().register("codex")["action"] == "registered"
+    assert Installer().register("codex")["action"] == "already"
+    assert _codex_toml(tmp_path).read_text().count("[mcp_servers.codeintel]") == 1  # not duplicated
+
+
+# --------------------------------------------------------------------------- json agents
+
+def test_claude_registers_json_mcp_servers(tmp_path, monkeypatch):
+    monkeypatch.setenv("HOME", str(tmp_path))
+    res = Installer().register("claude")
+    assert res["ok"]
+    data = json.loads((tmp_path / ".claude" / "settings.json").read_text())
+    assert data["mcpServers"]["codeintel"] == {"command": "codeintel", "args": ["serve"]}
+
+
+def test_claude_preserves_unrelated_settings(tmp_path, monkeypatch):
+    monkeypatch.setenv("HOME", str(tmp_path))
+    s = tmp_path / ".claude" / "settings.json"
+    s.parent.mkdir(parents=True)
+    s.write_text(json.dumps({"theme": "dark", "mcpServers": {"other": {"command": "x"}}}))
+    Installer().register("claude")
+    data = json.loads(s.read_text())
+    assert data["theme"] == "dark"                # unrelated key preserved
+    assert "other" in data["mcpServers"]          # other server preserved
+    assert "codeintel" in data["mcpServers"]      # ours added
+
+
+def test_zed_uses_context_servers_key(tmp_path, monkeypatch):
+    monkeypatch.setenv("HOME", str(tmp_path))
+    Installer().register("zed")
+    data = json.loads((tmp_path / ".config" / "zed" / "settings.json").read_text())
+    assert "codeintel" in data["context_servers"]
+
+
+# --------------------------------------------------------------------------- misc
+
+def test_unknown_agent_fails_safely():
+    res = Installer().register("nonesuch")
+    assert res["ok"] is False and res["action"] == "failed" and "unknown" in res["reason"]
+
+
+def test_register_all_covers_every_agent(tmp_path, monkeypatch):
+    monkeypatch.setenv("HOME", str(tmp_path))
+    results = Installer().register_all()
+    assert {r["agent"] for r in results} == {"claude", "codex", "gemini", "zed"}
+    assert all(r["ok"] for r in results)

codecortex-0.8.1/src/codeintel/__init__.py

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

codecortex-0.8.1/src/codeintel/installer.py

@@ -1,113 +0,0 @@
-from __future__ import annotations
-
-import json
-import os
-import pathlib
-
-_AGENTS = ["claude", "codex", "gemini", "zed"]
-
-
-def _atomic_write_text(path: pathlib.Path, text: str) -> None:
-    """Write via a sibling temp file + os.replace so an interrupted write can never truncate
-    the user's existing agent config (which holds unrelated settings) to a partial/empty file.
-    The temp lives in the same directory as ``path`` so the replace stays on one filesystem."""
-    tmp = path.with_name(path.name + ".codeintel.tmp")
-    tmp.write_text(text, encoding="utf-8")
-    os.replace(tmp, path)
-
-_CONFIG: dict[str, dict] = {
-    "claude": {
-        "path": "~/.claude/settings.json",
-        "key": ["mcpServers", "codeintel"],
-        "value": {"command": "codeintel", "args": ["serve"]},
-    },
-    "codex": {
-        "path": "~/.codex/config.json",
-        "key": ["mcpServers", "codeintel"],
-        "value": {"command": "codeintel", "args": ["serve"]},
-    },
-    "gemini": {
-        "path": "~/.gemini/settings.json",
-        "key": ["mcpServers", "codeintel"],
-        "value": {"command": "codeintel", "args": ["serve"]},
-    },
-    "zed": {
-        "path": "~/.config/zed/settings.json",
-        "key": ["context_servers", "codeintel"],
-        "value": {"command": {"path": "codeintel", "args": ["serve"]}},
-    },
-}
-
-
-def _get_nested(data: dict, keys: list[str]):
-    node = data
-    for k in keys:
-        if not isinstance(node, dict) or k not in node:
-            return None
-        node = node[k]
-    return node
-
-
-def _set_nested(data: dict, keys: list[str], value) -> None:
-    node = data
-    for k in keys[:-1]:
-        if k not in node or not isinstance(node[k], dict):
-            node[k] = {}
-        node = node[k]
-    node[keys[-1]] = value
-
-
-class Installer:
-    def register(self, agent: str) -> dict:
-        spec = _CONFIG.get(agent)
-        if spec is None:
-            return {
-                "agent": agent,
-                "path": "",
-                "ok": False,
-                "action": "failed",
-                "reason": f"unknown agent '{agent}'",
-            }
-
-        config_path = pathlib.Path(spec["path"]).expanduser()
-        try:
-            if config_path.exists():
-                data = json.loads(config_path.read_text(encoding="utf-8"))
-                if not isinstance(data, dict):
-                    data = {}
-            else:
-                data = {}
-
-            current = _get_nested(data, spec["key"])
-            if current == spec["value"]:
-                return {
-                    "agent": agent,
-                    "path": str(config_path),
-                    "ok": True,
-                    "action": "already",
-                    "reason": "",
-                }
-
-            config_path.parent.mkdir(parents=True, exist_ok=True)
-            _set_nested(data, spec["key"], spec["value"])
-            _atomic_write_text(config_path, json.dumps(data, indent=2))
-
-            return {
-                "agent": agent,
-                "path": str(config_path),
-                "ok": True,
-                "action": "registered",
-                "reason": "",
-            }
-
-        except Exception as exc:
-            return {
-                "agent": agent,
-                "path": str(config_path),
-                "ok": False,
-                "action": "failed",
-                "reason": str(exc),
-            }
-
-    def register_all(self) -> list[dict]:
-        return [self.register(agent) for agent in _AGENTS]