codemesh 0.1.1__py3-none-any.whl

codemesh/__init__.py

@@ -0,0 +1,5 @@
+"""Graph-enhanced retrieval-augmented generation for code."""
+
+from __future__ import annotations
+
+__version__ = "0.1.1"

codemesh/__main__.py

@@ -0,0 +1,8 @@
+"""Entry point: python -m codemesh."""
+
+from __future__ import annotations
+
+from codemesh.cli.main import app
+
+if __name__ == "__main__":
+    app()

codemesh/cli/__init__.py

@@ -0,0 +1,3 @@
+"""CLI application."""
+
+from __future__ import annotations

codemesh/cli/init.py

@@ -0,0 +1,208 @@
+# mypy: ignore-errors
+"""Project initialization — creates .codemesh/ directory and agent instructions."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+_CLAUDE_MD_TEMPLATE = """## CodeMesh
+
+CodeMesh builds a semantic knowledge graph of codebases for faster, smarter code exploration.
+
+### If `.codemesh/` exists in the project
+
+**NEVER call `codemesh_explore` or `codemesh_context` directly in the main session.** These tools return large amounts of source code that fills up main session context. Instead, ALWAYS spawn an Explore agent for any exploration question (e.g., "how does X work?", "explain the Y system", "where is Z implemented?").
+
+**When spawning Explore agents**, include this instruction in the prompt:
+
+> This project has CodeMesh initialized (.codemesh/ exists). Use `codemesh_explore` as your PRIMARY tool — it returns full source code sections from all relevant files in one call.
+>
+> **Rules:**
+> 1. Follow the explore call budget in the `codemesh_explore` tool description — it scales automatically based on project size.
+> 2. Do NOT re-read files that codemesh_explore already returned source code for. The source sections are complete and authoritative.
+> 3. Only fall back to grep/glob/read for files listed under "Additional relevant files" if you need more detail, or if codemesh returned no results.
+
+**The main session may only use these lightweight tools directly** (for targeted lookups before making edits, not for exploration):
+
+| Tool | Use For |
+|------|---------|
+| `codemesh_search` | Find symbols by name |
+| `codemesh_callers` / `codemesh_callees` | Trace call flow |
+| `codemesh_impact` | Check what's affected before editing |
+| `codemesh_node` | Get a single symbol's details |
+
+### If `.codemesh/` does NOT exist
+
+At the start of a session, ask the user if they'd like to initialize CodeMesh:
+
+"I notice this project doesn't have CodeMesh initialized. Would you like me to run `codemesh init -i` to build a code knowledge graph?"
+"""
+
+_CURSOR_RULES_TEMPLATE = """---
+description: CodeMesh code intelligence
+globs: *
+alwaysApply: true
+---
+
+## CodeMesh
+
+CodeMesh builds a semantic knowledge graph of codebases for faster, smarter code exploration.
+
+### If `.codemesh/` exists in the project
+
+Use CodeMesh MCP tools as your PRIMARY exploration method:
+
+1. `codemesh_explore` — Return source for several related symbols grouped by file, plus a relationship map, in one call. Use this as your main exploration tool.
+2. `codemesh_callers` / `codemesh_callees` — Trace call flow
+3. `codemesh_impact` — Check what's affected before editing
+4. `codemesh_search` — Find symbols by name
+
+### If `.codemesh/` does NOT exist
+
+At the start of a session, ask the user if they'd like to initialize CodeMesh:
+
+"I notice this project doesn't have CodeMesh initialized. Would you like me to run `codemesh init -i` to build a code knowledge graph?"
+"""
+
+_CODEX_TEMPLATE = """## CodeMesh
+
+CodeMesh builds a semantic knowledge graph of codebases for faster, smarter code exploration.
+
+### If `.codemesh/` exists in the project
+
+Use CodeMesh MCP tools as your PRIMARY exploration method:
+- `codemesh_explore` — Return source for related symbols grouped by file (main exploration tool)
+- `codemesh_callers` / `codemesh_callees` — Trace call flow
+- `codemesh_impact` — Check what's affected before editing
+- `codemesh_search` — Find symbols by name
+
+### If `.codemesh/` does NOT exist
+
+At the start of a session, ask: "I notice this project doesn't have CodeMesh initialized. Would you like me to run `codemesh init -i` to build a code knowledge graph?"
+"""
+
+_HERMES_TEMPLATE = """## CodeMesh
+
+CodeMesh builds a semantic knowledge graph of codebases for faster, smarter code exploration.
+
+### If `.codemesh/` exists in the project
+
+Use CodeMesh MCP tools as your PRIMARY exploration method:
+- `codemesh_explore` — Return source for related symbols grouped by file (main exploration tool)
+- `codemesh_callers` / `codemesh_callees` — Trace call flow
+- `codemesh_impact` — Check what's affected before editing
+- `codemesh_search` — Find symbols by name
+
+### If `.codemesh/` does NOT exist
+
+At the start of a session, ask: "I notice this project doesn't have CodeMesh initialized. Would you like me to run `codemesh init -i` to build a code knowledge graph?"
+"""
+
+
+def init_project(root: Path, interactive: bool = False) -> dict:
+    """Initialize CodeMesh in a project.
+
+    Creates .codemesh/ directory and writes agent instruction files.
+    Returns a dict with paths created.
+    """
+    root = root.resolve()
+    codemesh_dir = root / ".codemesh"
+
+    created = {}
+
+    # Create .codemesh directory
+    codemesh_dir.mkdir(parents=True, exist_ok=True)
+    created["codemesh_dir"] = str(codemesh_dir)
+
+    # Write CLAUDE.md (project-level instructions for Claude Code)
+    claude_md = root / "CLAUDE.md"
+    if interactive and claude_md.exists() and not _confirm_overwrite("CLAUDE.md"):
+        # Write to .codemesh/CLAUDE.md instead
+        claude_md = codemesh_dir / "CLAUDE.md"
+    claude_md.write_text(_CLAUDE_MD_TEMPLATE)
+    created["claude_md"] = str(claude_md)
+
+    # Write Cursor rules
+    cursor_dir = root / ".cursor" / "rules"
+    cursor_dir.mkdir(parents=True, exist_ok=True)
+    cursor_rules = cursor_dir / "codemesh.mdc"
+    cursor_rules.write_text(_CURSOR_RULES_TEMPLATE)
+    created["cursor_rules"] = str(cursor_rules)
+
+    # Write AGENTS.md (global instructions for Codex/opencode)
+    agents_md = root / "AGENTS.md"
+    if interactive and agents_md.exists() and not _confirm_overwrite("AGENTS.md"):
+        agents_md = codemesh_dir / "AGENTS.md"
+    agents_md.write_text(_CODEX_TEMPLATE)
+    created["agents_md"] = str(agents_md)
+
+    # Write Hermes instructions
+    hermes_md = codemesh_dir / "HERMES.md"
+    hermes_md.write_text(_HERMES_TEMPLATE)
+    created["hermes_md"] = str(hermes_md)
+
+    # Write config file
+    config_file = codemesh_dir / "config.json"
+    if not config_file.exists():
+        import json
+
+        config = {
+            "version": 1,
+            "root": str(root),
+            "ignore": [".git", "node_modules", "__pycache__", ".venv", "venv"],
+        }
+        config_file.write_text(json.dumps(config, indent=2))
+        created["config"] = str(config_file)
+
+    return created
+
+
+def _confirm_overwrite(name: str) -> bool:
+    """Ask user to confirm overwriting an existing file."""
+    response = input(f"{name} already exists. Overwrite? [y/N] ").strip().lower()
+    return response in ("y", "yes")
+
+
+def uninit_project(root: Path, force: bool = False) -> dict:
+    """Remove CodeMesh from a project.
+
+    Removes .codemesh/ directory and agent instruction files.
+    Returns a dict with paths removed.
+    """
+    root = root.resolve()
+    codemesh_dir = root / ".codemesh"
+    removed = []
+
+    # Remove instruction files
+    for f in ["CLAUDE.md", "AGENTS.md"]:
+        p = root / f
+        if p.exists():
+            content = p.read_text()
+            if "CodeMesh" in content and (force or _confirm_remove(f)):
+                p.unlink()
+                removed.append(str(p))
+
+    # Remove Cursor rules
+    cursor_rules = root / ".cursor" / "rules" / "codemesh.mdc"
+    if cursor_rules.exists() and (force or _confirm_remove("cursor rules")):
+        cursor_rules.unlink()
+        removed.append(str(cursor_rules))
+
+    # Remove .codemesh directory
+    if codemesh_dir.exists():
+        import shutil
+
+        if force or _confirm_remove(".codemesh/"):
+            shutil.rmtree(codemesh_dir)
+            removed.append(str(codemesh_dir))
+
+    return {"removed": removed}
+
+
+def _confirm_remove(name: str) -> bool:
+    """Ask user to confirm removing a file."""
+    response = input(f"Remove {name}? [y/N] ").strip().lower()
+    return response in ("y", "yes")

codemesh/cli/install_cmd.py

@@ -0,0 +1,208 @@
+# mypy: ignore-errors
+"""Install command — auto-configures CodeMesh MCP server for AI coding agents."""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+_CLAUDE_MCP_CONFIG = {
+    "mcpServers": {
+        "codemesh": {
+            "type": "stdio",
+            "command": "codemesh",
+            "args": ["serve", "--transport", "stdio"],
+        }
+    }
+}
+
+_CLAUDE_PERMISSIONS = {
+    "permissions": {
+        "allow": [
+            "mcp__codemesh__codemesh_search",
+            "mcp__codemesh__codemesh_context",
+            "mcp__codemesh__codemesh_callers",
+            "mcp__codemesh__codemesh_callees",
+            "mcp__codemesh__codemesh_impact",
+            "mcp__codemesh__codemesh_node",
+            "mcp__codemesh__codemesh_status",
+            "mcp__codemesh__codemesh_files",
+            "mcp__codemesh__codemesh_explore",
+        ]
+    }
+}
+
+
+def _find_claude_json_dir() -> Path | None:
+    """Find the Claude Code configuration directory."""
+    candidates = [
+        Path.home() / ".claude",
+        Path.home() / ".config" / "claude",
+    ]
+    for c in candidates:
+        if c.exists():
+            return c
+    # Create the default location
+    claude_dir = Path.home() / ".claude"
+    claude_dir.mkdir(parents=True, exist_ok=True)
+    return claude_dir
+
+
+def _merge_json_file(path: Path, new_data: dict) -> dict:
+    """Merge new data into an existing JSON file."""
+    existing: dict = {}
+    if path.exists():
+        try:
+            existing = json.loads(path.read_text())
+        except (json.JSONDecodeError, OSError):
+            existing = {}
+
+    # Merge MCP servers
+    if "mcpServers" in new_data:
+        existing.setdefault("mcpServers", {})
+        existing["mcpServers"].update(new_data["mcpServers"])
+
+    # Merge permissions
+    if "permissions" in new_data and "allow" in new_data["permissions"]:
+        existing.setdefault("permissions", {"allow": []})
+        perms_allow = existing["permissions"].get("allow", [])
+        for item in new_data["permissions"]["allow"]:
+            if item not in perms_allow:
+                perms_allow.append(item)
+        existing["permissions"]["allow"] = perms_allow
+
+    return existing
+
+
+def install_claude(root: Path, global_config: bool = True) -> dict:
+    """Configure Claude Code to use CodeMesh MCP server.
+
+    Args:
+        root: Project root (for project-local config)
+        global_config: If True, write to ~/.claude.json (global).
+                      If False, write to .claude.json in project root.
+    """
+    result = {"claude_json": None, "claude_settings": None, "claude_md": None}
+
+    if global_config:
+        claude_dir = _find_claude_json_dir()
+        if claude_dir is None:
+            return result
+        claude_json = claude_dir / "claude.json"
+        claude_settings = claude_dir / "settings.json"
+    else:
+        claude_json = root / ".claude.json"
+        claude_settings = root / ".claude_settings.json"
+
+    # Merge MCP config
+    if claude_json.exists():
+        existing = json.loads(claude_json.read_text())
+        existing_mcp = existing.get("mcpServers", {})
+        if "codemesh" in existing_mcp:
+            result["claude_json"] = str(claude_json) + " (already configured)"
+            return result
+
+    merged = _merge_json_file(claude_json, _CLAUDE_MCP_CONFIG)
+    claude_json.write_text(json.dumps(merged, indent=2))
+    result["claude_json"] = str(claude_json)
+
+    # Merge permissions
+    merged_settings = _merge_json_file(claude_settings, _CLAUDE_PERMISSIONS)
+    claude_settings.write_text(json.dumps(merged_settings, indent=2))
+    result["claude_settings"] = str(claude_settings)
+
+    return result
+
+
+def install_cursor(root: Path) -> dict:
+    """Configure Cursor to use CodeMesh MCP server.
+
+    Cursor uses .cursor/mcp.json in the project directory.
+    """
+    result = {"cursor_mcp": None}
+
+    cursor_dir = root / ".cursor"
+    cursor_dir.mkdir(parents=True, exist_ok=True)
+    mcp_json = cursor_dir / "mcp.json"
+
+    config = {}
+    if mcp_json.exists():
+        try:
+            config = json.loads(mcp_json.read_text())
+        except (json.JSONDecodeError, OSError):
+            config = {}
+
+    config.setdefault("mcpServers", {})
+    if "codemesh" in config.get("mcpServers", {}):
+        result["cursor_mcp"] = str(mcp_json) + " (already configured)"
+        return result
+
+    config["mcpServers"]["codemesh"] = {
+        "type": "stdio",
+        "command": "codemesh",
+        "args": ["serve", "--transport", "stdio"],
+    }
+    mcp_json.write_text(json.dumps(config, indent=2))
+    result["cursor_mcp"] = str(mcp_json)
+
+    return result
+
+
+def install_codex(root: Path) -> dict:
+    """Configure Codex CLI to use CodeMesh MCP server.
+
+    Codex uses ~/.codex/config.json.
+    """
+    result = {"codex_config": None}
+
+    codex_dir = Path.home() / ".codex"
+    codex_dir.mkdir(parents=True, exist_ok=True)
+    config_file = codex_dir / "config.json"
+
+    config: dict = {}
+    if config_file.exists():
+        try:
+            config = json.loads(config_file.read_text())
+        except (json.JSONDecodeError, OSError):
+            config = {}
+
+    config.setdefault("mcpServers", {})
+    if "codemesh" in config.get("mcpServers", {}):
+        result["codex_config"] = str(config_file) + " (already configured)"
+        return result
+
+    config["mcpServers"]["codemesh"] = {
+        "type": "stdio",
+        "command": "codemesh",
+        "args": ["serve", "--transport", "stdio"],
+    }
+    config_file.write_text(json.dumps(config, indent=2))
+    result["codex_config"] = str(config_file)
+
+    return result
+
+
+def detect_agents() -> list[str]:
+    """Detect which AI coding agents are installed."""
+    agents = []
+
+    # Check for Claude Code
+    claude_dir = _find_claude_json_dir()
+    if claude_dir and claude_dir.exists():
+        agents.append("claude")
+
+    # Check for Cursor
+    cursor_check = Path.home() / ".cursor"
+    if cursor_check.exists():
+        agents.append("cursor")
+
+    # Check for Codex CLI
+    import shutil
+
+    if shutil.which("codex"):
+        agents.append("codex")
+
+    return agents