ctxgraph 0.1.0__py3-none-any.whl

ctxgraph/cli/main.py

@@ -0,0 +1,253 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from ctxgraph.capsule.renderer import render_capsule, render_project_overview
+from ctxgraph.clients.models import ModelMode, get_mode_config
+from ctxgraph.graph.builder import build_graph, get_storage
+from ctxgraph.graph.query import search_relevant_nodes
+
+app = typer.Typer(name="ctx", help="Context graph engine for AI coding assistants")
+console = Console()
+
+
+@app.callback()
+def callback():
+    pass
+
+
+@app.command()
+def build(
+    repo_path: Optional[str] = typer.Argument(
+        None, help="Path to repository (default: current directory)"
+    ),
+    repo: Optional[str] = typer.Option(
+        None, "--repo", "-r", help="Repository path (synonym for positional)"
+    ),
+    exclude: Optional[list[str]] = typer.Option(
+        None, "--exclude", "-e", help="Additional exclude patterns"
+    ),
+    db_path: Optional[str] = typer.Option(
+        None, "--db", "-d", help="Custom database path"
+    ),
+):
+    """Build the knowledge graph for a repository."""
+    effective = repo or repo_path
+    path = Path(effective).resolve() if effective else Path.cwd()
+
+    if not (path / ".ctxgraph").exists():
+        (path / ".ctxgraph").mkdir(parents=True, exist_ok=True)
+
+    with console.status(f"Analyzing {path}..."):
+        stats = build_graph(path, db_path, exclude)
+
+    table = Table(title="Graph Build Complete")
+    table.add_column("Metric", style="cyan")
+    table.add_column("Value", style="green")
+
+    table.add_row("Files Analyzed", str(stats["files_analyzed"]))
+    table.add_row("Files Skipped", str(stats.get("files_skipped", 0)))
+    table.add_row("Errors", str(stats.get("errors", 0)))
+    table.add_row("Total Nodes", str(stats.get("total_nodes", 0)))
+    table.add_row("Total Edges", str(stats.get("total_edges", 0)))
+    table.add_row("Time", f"{stats.get('elapsed_seconds', 0)}s")
+
+    console.print(table)
+    console.print(f"\nGraph stored in: [bold]{path / '.ctxgraph' / 'graph.db'}[/bold]")
+
+
+@app.command()
+def capsule(
+    query: str = typer.Argument(..., help="Task description"),
+    repo_path: Optional[str] = typer.Option(
+        None, "--repo", "-r", help="Repository path"
+    ),
+    max_nodes: Optional[int] = typer.Option(
+        None, "--max-nodes", "-n", help="Maximum nodes in capsule"
+    ),
+    mode: str = typer.Option(
+        "balanced", "--mode", "-m", help="Model mode: fast, balanced, deep"
+    ),
+    overview: bool = typer.Option(
+        False, "--overview", "-o", help="Generate project overview instead"
+    ),
+):
+    """Generate a context capsule for Claude."""
+    path = Path(repo_path).resolve() if repo_path else Path.cwd()
+    model_mode = ModelMode.from_str(mode)
+    mode_cfg = get_mode_config(model_mode)
+
+    storage = get_storage(path)
+    if storage is None:
+        console.print(
+            "[red]No graph found. Run [bold]ctx build[/bold] first.[/red]"
+        )
+        raise typer.Exit(1)
+
+    if overview:
+        result = render_project_overview(storage)
+    else:
+        result = render_capsule(
+            storage,
+            query,
+            max_nodes=max_nodes or mode_cfg["max_nodes"],
+        )
+
+    console.print(result)
+
+
+@app.command()
+def query(
+    query: str = typer.Argument(..., help="Search query"),
+    repo_path: Optional[str] = typer.Option(
+        None, "--repo", "-r", help="Repository path"
+    ),
+    mode: str = typer.Option(
+        "balanced", "--mode", "-m", help="Model mode: fast, balanced, deep"
+    ),
+):
+    """Search the knowledge graph."""
+    path = Path(repo_path).resolve() if repo_path else Path.cwd()
+    model_mode = ModelMode.from_str(mode)
+    mode_cfg = get_mode_config(model_mode)
+
+    storage = get_storage(path)
+    if storage is None:
+        console.print(
+            "[red]No graph found. Run [bold]ctx build[/bold] first.[/red]"
+        )
+        raise typer.Exit(1)
+
+    results = search_relevant_nodes(
+        storage,
+        query,
+        max_nodes=mode_cfg["max_nodes"],
+        max_depth=mode_cfg["max_depth"],
+    )
+
+    if not results:
+        console.print("[yellow]No matches found.[/yellow]")
+        return
+
+    table = Table(title=f"Search Results: {query}")
+    table.add_column("Type", style="cyan")
+    table.add_column("Name", style="green")
+    table.add_column("Path", style="blue")
+    table.add_column("Relevance", style="yellow")
+
+    for node, score in results:
+        type_tag = {"file": "F", "class": "C", "function": "M", "module": "M"}
+        table.add_row(
+            type_tag.get(node.type, "?"),
+            node.name,
+            node.path or "-",
+            str(score),
+        )
+
+    console.print(table)
+
+
+@app.command()
+def view(
+    repo_path: Optional[str] = typer.Option(
+        None, "--repo", "-r", help="Repository path"
+    ),
+    port: Optional[int] = typer.Option(None, "--port", "-p", help="Port for server"),
+    output: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Save HTML to file"
+    ),
+    open_browser: bool = typer.Option(
+        True, "--open/--no-open", help="Open in browser automatically"
+    ),
+):
+    """Visualize the dependency graph in a browser."""
+    from ctxgraph.view.visualizer import render_view
+
+    path = Path(repo_path).resolve() if repo_path else Path.cwd()
+    storage = get_storage(path)
+    if storage is None:
+        console.print(
+            "[red]No graph found. Run [bold]ctx build[/bold] first.[/red]"
+        )
+        raise typer.Exit(1)
+
+    html = render_view(storage)
+
+    if output:
+        out_path = Path(output)
+        out_path.write_text(html, encoding="utf-8")
+        console.print(f"Saved to [bold]{out_path}[/bold]")
+    else:
+        out_path = path / ".ctxgraph" / "graph.html"
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+        out_path.write_text(html, encoding="utf-8")
+        console.print(f"Saved to [bold]{out_path}[/bold]")
+
+    if open_browser:
+        import webbrowser
+
+        webbrowser.open(f"file://{out_path.absolute()}")
+        console.print("Opened in browser.")
+
+
+@app.command()
+def serve(
+    repo_path: Optional[str] = typer.Option(
+        None, "--repo", "-r", help="Repository path"
+    ),
+    port: Optional[int] = typer.Option(
+        None, "--port", "-p", help="Port for SSE mode (default: stdio mode)"
+    ),
+):
+    """Start MCP server for dynamic graph queries (MCP protocol)."""
+    from ctxgraph.mcp.server import run_server
+
+    if port:
+        console.print(f"[yellow]SSE mode on port {port} - not yet supported, falling back to stdio[/yellow]")
+    run_server(repo_path)
+
+
+@app.command()
+def info(
+    repo_path: Optional[str] = typer.Option(
+        None, "--repo", "-r", help="Repository path"
+    ),
+):
+    """Show graph statistics."""
+    path = Path(repo_path).resolve() if repo_path else Path.cwd()
+    storage = get_storage(path)
+    if storage is None:
+        console.print(
+            "[red]No graph found. Run [bold]ctx build[/bold] first.[/red]"
+        )
+        raise typer.Exit(1)
+
+    stats = storage.stats()
+    build_time = storage.get_metadata("build_time")
+
+    table = Table(title="Graph Info")
+    table.add_column("Metric", style="cyan")
+    table.add_column("Value", style="green")
+
+    table.add_row("Total Nodes", str(stats["nodes"]))
+    table.add_row("Total Edges", str(stats["edges"]))
+
+    plural_map = {"file": "files", "class": "classes", "function": "functions", "module": "modules"}
+    for t, cnt in stats.get("types", {}).items():
+        label = plural_map.get(t, t + "s")
+        table.add_row(f"  {label}", str(cnt))
+
+    if build_time:
+        table.add_row("Last Build", build_time)
+
+    console.print(table)
+
+
+if __name__ == "__main__":
+    app()

ctxgraph/clients/models.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from enum import Enum
+from typing import Optional
+
+
+class ModelMode(str, Enum):
+    FAST = "fast"
+    BALANCED = "balanced"
+    DEEP = "deep"
+
+    @classmethod
+    def from_str(cls, value: str) -> "ModelMode":
+        value = value.lower().strip()
+        for mode in cls:
+            if mode.value == value:
+                return mode
+        return cls.BALANCED
+
+
+MODE_CONFIG = {
+    ModelMode.FAST: {
+        "description": "Quick responses, minimal analysis (Sonnet-class)",
+        "max_nodes": 10,
+        "max_depth": 1,
+        "summary_length": 100,
+    },
+    ModelMode.BALANCED: {
+        "description": "Balanced speed and depth (default)",
+        "max_nodes": 20,
+        "max_depth": 2,
+        "summary_length": 200,
+    },
+    ModelMode.DEEP: {
+        "description": "Deep analysis, full context (Opus-class)",
+        "max_nodes": 40,
+        "max_depth": 3,
+        "summary_length": 500,
+    },
+}
+
+
+def get_mode_config(mode: ModelMode) -> dict:
+    return MODE_CONFIG[mode]

ctxgraph/config/providers.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+import json
+import urllib.request
+import urllib.error
+from typing import Optional
+
+from ctxgraph.config.settings import Settings
+
+
+def chat_completion(
+    settings: Settings,
+    system_prompt: str,
+    user_prompt: str,
+) -> Optional[str]:
+    provider = settings.provider
+
+    if provider == "ollama":
+        return _ollama_chat(settings, system_prompt, user_prompt)
+    elif provider == "claude":
+        return _claude_chat(settings, system_prompt, user_prompt)
+    elif provider == "openai":
+        return _openai_chat(settings, system_prompt, user_prompt)
+    else:
+        return _custom_chat(settings, system_prompt, user_prompt)
+
+
+def generate_summary(
+    settings: Settings,
+    code: str,
+    context: str = "",
+) -> Optional[str]:
+    system = "You are a code analysis assistant. Summarize the following code concisely in 1-2 sentences."
+    user = f"Context: {context}\n\nCode:\n```python\n{code[:2000]}\n```"
+
+    return chat_completion(settings, system, user)
+
+
+def _ollama_chat(settings: Settings, system: str, user: str) -> Optional[str]:
+    url = settings.get_chat_url()
+    payload = {
+        "model": settings.model,
+        "messages": [
+            {"role": "system", "content": system},
+            {"role": "user", "content": user},
+        ],
+        "stream": False,
+        "temperature": settings.temperature,
+    }
+
+    try:
+        data = json.dumps(payload).encode()
+        req = urllib.request.Request(
+            url, data=data, headers={"Content-Type": "application/json"}
+        )
+        with urllib.request.urlopen(req, timeout=60) as resp:
+            result = json.loads(resp.read())
+            return result.get("message", {}).get("content", "")
+    except (urllib.error.URLError, json.JSONDecodeError, TimeoutError):
+        return None
+
+
+def _claude_chat(settings: Settings, system: str, user: str) -> Optional[str]:
+    api_key = settings.api_key
+    if not api_key:
+        return None
+
+    url = settings.get_chat_url()
+    payload = {
+        "model": settings.model,
+        "system": system,
+        "messages": [{"role": "user", "content": user}],
+        "max_tokens": settings.max_tokens,
+        "temperature": settings.temperature,
+    }
+
+    try:
+        data = json.dumps(payload).encode()
+        req = urllib.request.Request(
+            url,
+            data=data,
+            headers={
+                "Content-Type": "application/json",
+                "x-api-key": api_key,
+                "anthropic-version": "2023-06-01",
+            },
+        )
+        with urllib.request.urlopen(req, timeout=60) as resp:
+            result = json.loads(resp.read())
+            return result.get("content", [{}])[0].get("text", "")
+    except (urllib.error.URLError, json.JSONDecodeError, TimeoutError):
+        return None
+
+
+def _openai_chat(settings: Settings, system: str, user: str) -> Optional[str]:
+    api_key = settings.api_key
+    if not api_key:
+        return None
+
+    url = settings.get_chat_url()
+    payload = {
+        "model": settings.model,
+        "messages": [
+            {"role": "system", "content": system},
+            {"role": "user", "content": user},
+        ],
+        "max_tokens": settings.max_tokens,
+        "temperature": settings.temperature,
+    }
+
+    try:
+        data = json.dumps(payload).encode()
+        req = urllib.request.Request(
+            url,
+            data=data,
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {api_key}",
+            },
+        )
+        with urllib.request.urlopen(req, timeout=60) as resp:
+            result = json.loads(resp.read())
+            return result.get("choices", [{}])[0].get("message", {}).get("content", "")
+    except (urllib.error.URLError, json.JSONDecodeError, TimeoutError):
+        return None
+
+
+def _custom_chat(settings: Settings, system: str, user: str) -> Optional[str]:
+    url = settings.get_chat_url()
+    payload = {
+        "model": settings.model,
+        "messages": [
+            {"role": "system", "content": system},
+            {"role": "user", "content": user},
+        ],
+        "temperature": settings.temperature,
+    }
+
+    headers = {"Content-Type": "application/json"}
+    if settings.api_key:
+        headers["Authorization"] = f"Bearer {settings.api_key}"
+
+    try:
+        data = json.dumps(payload).encode()
+        req = urllib.request.Request(url, data=data, headers=headers)
+        with urllib.request.urlopen(req, timeout=60) as resp:
+            result = json.loads(resp.read())
+            return json.dumps(result)
+    except (urllib.error.URLError, json.JSONDecodeError, TimeoutError):
+        return None

ctxgraph/config/settings.py

@@ -0,0 +1,232 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Optional
+
+
+DEFAULT_CONFIG = {
+    "graph": {
+        "exclude": [],
+        "follow_symlinks": False,
+        "max_file_size_mb": 5,
+    },
+    "ai": {
+        "provider": "ollama",
+        "model": "qwen2.5-coder:7b",
+        "endpoint": "http://localhost:11434",
+        "api_key": None,
+        "temperature": 0.1,
+        "max_tokens": 4096,
+    },
+    "context": {
+        "mode": "balanced",
+        "max_nodes": 20,
+        "max_depth": 2,
+        "max_tokens": 4000,
+    },
+}
+
+PROVIDER_CONFIGS = {
+    "ollama": {
+        "endpoint_default": "http://localhost:11434",
+        "api_key_required": False,
+        "models": ["qwen2.5-coder:7b", "llama3.2", "llama3.1", "mistral", "codellama", "deepseek-coder"],
+        "chat_endpoint": "/api/chat",
+        "generate_endpoint": "/api/generate",
+    },
+    "claude": {
+        "endpoint_default": "https://api.anthropic.com/v1",
+        "api_key_required": True,
+        "models": ["claude-sonnet-4-20250514", "claude-haiku-3-5-20241022"],
+        "chat_endpoint": "/messages",
+        "api_key_env": "ANTHROPIC_API_KEY",
+    },
+    "openai": {
+        "endpoint_default": "https://api.openai.com/v1",
+        "api_key_required": True,
+        "models": ["gpt-4o", "gpt-4o-mini", "o3-mini"],
+        "chat_endpoint": "/chat/completions",
+        "api_key_env": "OPENAI_API_KEY",
+    },
+    "custom": {
+        "endpoint_default": None,
+        "api_key_required": False,
+        "models": [],
+        "chat_endpoint": "/v1/chat/completions",
+        "api_key_env": None,
+    },
+}
+
+
+class Settings:
+    def __init__(self, repo_path: Optional[Path] = None):
+        self.repo_path = Path(repo_path).resolve() if repo_path else Path.cwd()
+        self._data = dict(DEFAULT_CONFIG)
+        self._load()
+
+    def _load(self):
+        config_paths = [
+            self.repo_path / ".ctxgraph" / "config.toml",
+            self.repo_path / ".ctxgraph" / "config.json",
+            self.repo_path / "ctxgraph.toml",
+            self.repo_path / "ctxgraph.json",
+        ]
+
+        for path in config_paths:
+            if path.exists():
+                self._load_file(path)
+                break
+
+        self._apply_env_overrides()
+
+    def _load_file(self, path: Path):
+        text = path.read_text(encoding="utf-8")
+        if path.suffix == ".json":
+            parsed = json.loads(text)
+            self._deep_merge(self._data, parsed)
+        elif path.suffix == ".toml":
+            parsed = self._parse_toml(text)
+            self._deep_merge(self._data, parsed)
+
+    def _apply_env_overrides(self):
+        provider = self._data["ai"]["provider"]
+        pconfig = PROVIDER_CONFIGS.get(provider, {})
+
+        api_key_env = pconfig.get("api_key_env")
+        if api_key_env:
+            env_key = os.environ.get(api_key_env)
+            if env_key:
+                self._data["ai"]["api_key"] = env_key
+
+        env_endpoint = os.environ.get("CTXGRAPH_ENDPOINT")
+        if env_endpoint:
+            self._data["ai"]["endpoint"] = env_endpoint
+
+        env_model = os.environ.get("CTXGRAPH_MODEL")
+        if env_model:
+            self._data["ai"]["model"] = env_model
+
+        env_provider = os.environ.get("CTXGRAPH_PROVIDER")
+        if env_provider:
+            self._data["ai"]["provider"] = env_provider
+
+    @property
+    def provider(self) -> str:
+        return self._data["ai"]["provider"]
+
+    @property
+    def model(self) -> str:
+        return self._data["ai"]["model"]
+
+    @property
+    def endpoint(self) -> str:
+        return self._data["ai"]["endpoint"]
+
+    @property
+    def api_key(self) -> Optional[str]:
+        return self._data["ai"].get("api_key")
+
+    @property
+    def temperature(self) -> float:
+        return self._data["ai"].get("temperature", 0.1)
+
+    @property
+    def max_tokens(self) -> int:
+        return self._data["ai"].get("max_tokens", 4096)
+
+    @property
+    def exclude_patterns(self) -> list[str]:
+        return self._data["graph"].get("exclude", [])
+
+    @property
+    def context_mode(self) -> str:
+        return self._data["context"].get("mode", "balanced")
+
+    @property
+    def max_nodes(self) -> int:
+        return self._data["context"].get("max_nodes", 20)
+
+    @property
+    def max_depth(self) -> int:
+        return self._data["context"].get("max_depth", 2)
+
+    def get_provider_config(self) -> dict:
+        return PROVIDER_CONFIGS.get(self.provider, PROVIDER_CONFIGS["custom"])
+
+    def get_chat_url(self) -> str:
+        pconfig = self.get_provider_config()
+        endpoint = self.endpoint.rstrip("/")
+        return f"{endpoint}{pconfig.get('chat_endpoint', '/v1/chat/completions')}"
+
+    def to_dict(self) -> dict:
+        return dict(self._data)
+
+    @staticmethod
+    def _parse_toml(text: str) -> dict:
+        result = {}
+        current_section = result
+
+        for line in text.split("\n"):
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            if line.startswith("[") and line.endswith("]"):
+                section_name = line[1:-1].strip()
+                current_section = result.setdefault(section_name, {})
+            elif "=" in line:
+                key, _, value = line.partition("=")
+                key = key.strip()
+                value = value.strip()
+                value = value.strip('"').strip("'")
+                current_section[key] = value
+
+        return result
+
+    @staticmethod
+    def _deep_merge(base: dict, override: dict):
+        for key, value in override.items():
+            if key in base and isinstance(base[key], dict) and isinstance(value, dict):
+                Settings._deep_merge(base[key], value)
+            else:
+                base[key] = value
+
+
+def create_default_config(repo_path: Path):
+    config_dir = repo_path / ".ctxgraph"
+    config_dir.mkdir(parents=True, exist_ok=True)
+
+    config_path = config_dir / "config.toml"
+    if config_path.exists():
+        return
+
+    config_path.write_text(
+        """# ctxgraph configuration
+# https://github.com/anomalyco/ctxgraph
+
+[graph]
+# Additional exclude patterns (gitignore is used automatically)
+exclude = []
+
+[ai]
+# Provider: ollama, claude, openai, or custom
+provider = "ollama"
+# Model name
+model = "qwen2.5-coder:7b"
+# API endpoint
+endpoint = "http://localhost:11434"
+# API key (or set env var: ANTHROPIC_API_KEY, OPENAI_API_KEY)
+api_key = ""
+
+[context]
+# Mode: fast, balanced, deep
+mode = "balanced"
+# Max nodes to include in context capsule
+max_nodes = 20
+# Max BFS depth for dependency traversal
+max_depth = 2
+""",
+        encoding="utf-8",
+    )
+    return config_path