codexa 0.4.0__py3-none-any.whl

semantic_code_intelligence/config/settings.py

@@ -0,0 +1,260 @@
+"""Configuration settings for Semantic Code Intelligence."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+# Default directories to ignore during scanning
+DEFAULT_IGNORE_DIRS: set[str] = {
+    ".git",
+    "node_modules",
+    "build",
+    "dist",
+    "venv",
+    ".venv",
+    "__pycache__",
+    ".tox",
+    ".mypy_cache",
+    ".pytest_cache",
+    "egg-info",
+    ".eggs",
+    ".idea",
+    ".vscode",
+    "target",
+    "bin",
+    "obj",
+}
+
+# Default file extensions to index
+DEFAULT_EXTENSIONS: set[str] = {
+    ".py",
+    ".js",
+    ".ts",
+    ".jsx",
+    ".tsx",
+    ".java",
+    ".go",
+    ".rs",
+    ".c",
+    ".cpp",
+    ".h",
+    ".hpp",
+    ".rb",
+    ".php",
+    ".cs",
+    ".swift",
+    ".kt",
+    ".scala",
+    ".sh",
+    ".bash",
+    ".sql",
+    ".r",
+    ".lua",
+    ".dart",
+    ".ex",
+    ".exs",
+}
+
+CONFIG_DIR_NAME = ".codexa"
+CONFIG_FILE_NAME = "config.json"
+INDEX_DIR_NAME = "index"
+
+
+class EmbeddingConfig(BaseModel):
+    """Configuration for the embedding engine."""
+
+    model_name: str = Field(
+        default="all-MiniLM-L6-v2",
+        description="Sentence-transformers model name for embedding generation.",
+    )
+    chunk_size: int = Field(
+        default=512,
+        description="Maximum number of characters per code chunk.",
+    )
+    chunk_overlap: int = Field(
+        default=64,
+        description="Number of overlapping characters between consecutive chunks.",
+    )
+
+
+class SearchConfig(BaseModel):
+    """Configuration for the search engine."""
+
+    top_k: int = Field(
+        default=10,
+        description="Number of top results to return from similarity search.",
+    )
+    similarity_threshold: float = Field(
+        default=0.3,
+        description="Minimum similarity score threshold for results.",
+    )
+
+
+class IndexConfig(BaseModel):
+    """Configuration for the indexing system."""
+
+    ignore_dirs: set[str] = Field(default_factory=lambda: DEFAULT_IGNORE_DIRS.copy())
+    extensions: set[str] = Field(default_factory=lambda: DEFAULT_EXTENSIONS.copy())
+    use_incremental: bool = Field(
+        default=True,
+        description="Enable incremental indexing using file hashes.",
+    )
+
+
+class LLMConfig(BaseModel):
+    """Configuration for LLM provider integration."""
+
+    provider: str = Field(
+        default="mock",
+        description="LLM provider name: 'openai', 'ollama', or 'mock'.",
+    )
+    model: str = Field(
+        default="gpt-3.5-turbo",
+        description="Model name to use with the provider.",
+    )
+    api_key: str = Field(
+        default="",
+        description="API key for remote providers (e.g. OpenAI).",
+    )
+    base_url: str = Field(
+        default="",
+        description="Custom base URL for the LLM API endpoint.",
+    )
+    temperature: float = Field(
+        default=0.2,
+        description="Sampling temperature for LLM responses.",
+    )
+    max_tokens: int = Field(
+        default=2048,
+        description="Maximum tokens for LLM response generation.",
+    )
+    cache_enabled: bool = Field(
+        default=True,
+        description="Enable LLM response caching.",
+    )
+    cache_ttl_hours: int = Field(
+        default=24,
+        description="Time-to-live for cached LLM responses in hours.",
+    )
+    cache_max_entries: int = Field(
+        default=1000,
+        description="Maximum number of cached LLM responses.",
+    )
+    rate_limit_rpm: int = Field(
+        default=0,
+        description="Max requests per minute (0 = unlimited).",
+    )
+    rate_limit_tpm: int = Field(
+        default=0,
+        description="Max tokens per minute (0 = unlimited).",
+    )
+
+
+class QualityConfig(BaseModel):
+    """Configuration for code quality metrics and gate enforcement."""
+
+    complexity_threshold: int = Field(
+        default=10,
+        description="Minimum cyclomatic complexity to flag.",
+    )
+    min_maintainability: float = Field(
+        default=40.0,
+        description="Minimum maintainability index for quality gates.",
+    )
+    max_issues: int = Field(
+        default=20,
+        description="Maximum allowed quality issues for gates.",
+    )
+    snapshot_on_index: bool = Field(
+        default=False,
+        description="Automatically save a quality snapshot on indexing.",
+    )
+    history_limit: int = Field(
+        default=50,
+        description="Maximum number of snapshots to retain.",
+    )
+
+
+class AppConfig(BaseModel):
+    """Top-level application configuration."""
+
+    project_root: str = Field(
+        default=".",
+        description="Root path of the project being indexed.",
+    )
+    embedding: EmbeddingConfig = Field(default_factory=EmbeddingConfig)
+    search: SearchConfig = Field(default_factory=SearchConfig)
+    index: IndexConfig = Field(default_factory=IndexConfig)
+    llm: LLMConfig = Field(default_factory=LLMConfig)
+    quality: QualityConfig = Field(default_factory=QualityConfig)
+    verbose: bool = Field(default=False, description="Enable verbose output.")
+
+    @classmethod
+    def config_dir(cls, project_root: str | Path) -> Path:
+        """Return the .codexa config directory for a given project root."""
+        return Path(project_root).resolve() / CONFIG_DIR_NAME
+
+    @classmethod
+    def config_path(cls, project_root: str | Path) -> Path:
+        """Return the path to the config.json file."""
+        return cls.config_dir(project_root) / CONFIG_FILE_NAME
+
+    @classmethod
+    def index_dir(cls, project_root: str | Path) -> Path:
+        """Return the path to the index storage directory."""
+        return cls.config_dir(project_root) / INDEX_DIR_NAME
+
+
+def load_config(project_root: str | Path = ".") -> AppConfig:
+    """Load configuration from the project's .codexa/config.json.
+
+    Falls back to default configuration if the file doesn't exist.
+    """
+    config_path = AppConfig.config_path(project_root)
+    if config_path.exists():
+        data = json.loads(config_path.read_text(encoding="utf-8"))
+        return AppConfig.model_validate(data)
+    return AppConfig(project_root=str(Path(project_root).resolve()))
+
+
+def save_config(config: AppConfig, project_root: Optional[str | Path] = None) -> Path:
+    """Save configuration to the project's .codexa/config.json.
+
+    Creates the config directory if it doesn't exist.
+    Returns the path to the saved config file.
+    """
+    root = project_root or config.project_root
+    config_dir = AppConfig.config_dir(root)
+    config_dir.mkdir(parents=True, exist_ok=True)
+
+    config_path = AppConfig.config_path(root)
+    config_path.write_text(
+        config.model_dump_json(indent=2),
+        encoding="utf-8",
+    )
+    return config_path
+
+
+def init_project(project_root: str | Path = ".") -> tuple[AppConfig, Path]:
+    """Initialize a new project: create config dir, index dir, and default config.
+
+    Returns the config object and the path to the config file.
+    """
+    root = Path(project_root).resolve()
+    config = AppConfig(project_root=str(root))
+
+    # Create directories
+    config_dir = AppConfig.config_dir(root)
+    config_dir.mkdir(parents=True, exist_ok=True)
+    index_dir = AppConfig.index_dir(root)
+    index_dir.mkdir(parents=True, exist_ok=True)
+
+    # Save default config
+    config_path = save_config(config, root)
+
+    return config, config_path

semantic_code_intelligence/context/__init__.py

@@ -0,0 +1,19 @@
+"""Context engine package — code context building, call graphs, and dependency tracking."""
+
+from semantic_code_intelligence.context.engine import (
+    CallEdge,
+    CallGraph,
+    ContextBuilder,
+    ContextWindow,
+    DependencyMap,
+    FileDependency,
+)
+
+__all__ = [
+    "CallEdge",
+    "CallGraph",
+    "ContextBuilder",
+    "ContextWindow",
+    "DependencyMap",
+    "FileDependency",
+]

semantic_code_intelligence/context/engine.py

@@ -0,0 +1,429 @@
+"""Context engine — builds rich code context from parsed symbols.
+
+Provides:
+- ContextBuilder: assembles context windows around symbols
+- CallGraph: AST-based call/reference graph (tree-sitter powered)
+- DependencyMap: file-level dependency tracking from imports
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import tree_sitter
+
+from semantic_code_intelligence.parsing.parser import (
+    Symbol,
+    detect_language,
+    extract_imports,
+    get_language,
+    parse_file,
+)
+from semantic_code_intelligence.utils.logging import get_logger
+
+logger = get_logger("context")
+
+
+# ---------------------------------------------------------------------------
+# Context Builder
+# ---------------------------------------------------------------------------
+
+@dataclass
+class ContextWindow:
+    """A context window consisting of a focal symbol and surrounding context."""
+
+    focal_symbol: Symbol
+    related_symbols: list[Symbol] = field(default_factory=list)
+    imports: list[Symbol] = field(default_factory=list)
+    file_content: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize the context window to a plain dictionary."""
+        return {
+            "focal_symbol": self.focal_symbol.to_dict(),
+            "related_symbols": [s.to_dict() for s in self.related_symbols],
+            "imports": [s.to_dict() for s in self.imports],
+        }
+
+    def render(self, max_lines: int = 50) -> str:
+        """Render a human-readable context summary."""
+        lines: list[str] = []
+        lines.append(f"=== {self.focal_symbol.kind}: {self.focal_symbol.name} ===")
+        lines.append(f"File: {self.focal_symbol.file_path}")
+        lines.append(f"Lines: {self.focal_symbol.start_line}-{self.focal_symbol.end_line}")
+        lines.append("")
+
+        if self.imports:
+            lines.append("-- Imports --")
+            for imp in self.imports[:5]:
+                lines.append(f"  {imp.body.strip()}")
+            lines.append("")
+
+        lines.append("-- Source --")
+        body_lines = self.focal_symbol.body.split("\n")
+        for line in body_lines[:max_lines]:
+            lines.append(f"  {line}")
+        if len(body_lines) > max_lines:
+            lines.append(f"  ... ({len(body_lines) - max_lines} more lines)")
+
+        if self.related_symbols:
+            lines.append("")
+            lines.append("-- Related symbols --")
+            for sym in self.related_symbols[:10]:
+                lines.append(f"  {sym.kind} {sym.name} (L{sym.start_line})")
+
+        return "\n".join(lines)
+
+
+class ContextBuilder:
+    """Builds context windows for symbols within a repository."""
+
+    def __init__(self) -> None:
+        self._file_symbols: dict[str, list[Symbol]] = {}
+        self._file_contents: dict[str, str] = {}
+
+    def index_file(self, file_path: str, content: str | None = None) -> list[Symbol]:
+        """Parse and index a file, returning its symbols."""
+        if content is None:
+            try:
+                content = Path(file_path).read_text(encoding="utf-8", errors="replace")
+            except (OSError, PermissionError):
+                return []
+
+        symbols = parse_file(file_path, content)
+        self._file_symbols[file_path] = symbols
+        self._file_contents[file_path] = content
+        return symbols
+
+    def get_symbols(self, file_path: str) -> list[Symbol]:
+        """Get cached symbols for a file."""
+        return self._file_symbols.get(file_path, [])
+
+    def get_all_symbols(self) -> list[Symbol]:
+        """Get all indexed symbols across all files."""
+        result: list[Symbol] = []
+        for symbols in self._file_symbols.values():
+            result.extend(symbols)
+        return result
+
+    def find_symbol(self, name: str, kind: str | None = None) -> list[Symbol]:
+        """Find symbols by name, optionally filtered by kind."""
+        results: list[Symbol] = []
+        for symbols in self._file_symbols.values():
+            for s in symbols:
+                if s.name == name:
+                    if kind is None or s.kind == kind:
+                        results.append(s)
+        return results
+
+    def build_context(self, symbol: Symbol) -> ContextWindow:
+        """Build a context window around a specific symbol."""
+        file_path = symbol.file_path
+        symbols = self._file_symbols.get(file_path, [])
+        content = self._file_contents.get(file_path, "")
+
+        # Gather imports from the same file
+        imports = [s for s in symbols if s.kind == "import"]
+
+        # Gather related symbols (same file, excluding the focal one)
+        related = [
+            s for s in symbols
+            if s is not symbol and s.kind != "import"
+        ]
+
+        return ContextWindow(
+            focal_symbol=symbol,
+            related_symbols=related,
+            imports=imports,
+            file_content=content,
+        )
+
+    def build_context_for_name(self, name: str) -> list[ContextWindow]:
+        """Build context windows for all symbols matching a name."""
+        symbols = self.find_symbol(name)
+        return [self.build_context(s) for s in symbols]
+
+
+# ---------------------------------------------------------------------------
+# Call Graph (lightweight reference-based)
+# ---------------------------------------------------------------------------
+
+@dataclass
+class CallEdge:
+    """An edge in the call graph."""
+
+    caller: str  # "file:name" or just "name"
+    callee: str
+    file_path: str
+    line: int
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize the call edge to a plain dictionary."""
+        return {
+            "caller": self.caller,
+            "callee": self.callee,
+            "file_path": self.file_path,
+            "line": self.line,
+        }
+
+
+class CallGraph:
+    """AST-based call graph built from tree-sitter function-call nodes.
+
+    Walks the AST of each callable symbol's body to find ``call`` nodes
+    (function/method invocations).  The callee name is resolved from the
+    AST node (``identifier`` / ``attribute`` / ``field_expression``) and
+    matched against indexed symbol names to produce precise edges.
+
+    Falls back to the regex heuristic only when tree-sitter cannot parse
+    the file (e.g. unsupported language).
+    """
+
+    # Node types that represent a function/method call across languages
+    _CALL_NODE_TYPES: set[str] = {
+        "call",                     # Python, Ruby, PHP
+        "call_expression",          # JS, TS, Go, Rust, C#, C++, Java
+        "method_invocation",        # Java
+        "invocation_expression",    # C#
+    }
+
+    def __init__(self) -> None:
+        self._edges: list[CallEdge] = []
+        self._callers: dict[str, list[CallEdge]] = {}  # callee -> list of callers
+        self._callees: dict[str, list[CallEdge]] = {}  # caller -> list of callees
+
+    # ----- public API -----
+
+    def build(self, symbols: list[Symbol]) -> None:
+        """Build the call graph from a list of symbols using AST analysis."""
+        self._edges.clear()
+        self._callers.clear()
+        self._callees.clear()
+
+        callable_symbols = [
+            s for s in symbols if s.kind in ("function", "method", "class")
+        ]
+        callee_names: set[str] = {s.name for s in callable_symbols}
+
+        # Group symbols by file so we parse each file once
+        file_symbols: dict[str, list[Symbol]] = {}
+        for sym in callable_symbols:
+            file_symbols.setdefault(sym.file_path, []).append(sym)
+
+        for file_path, syms in file_symbols.items():
+            lang_name = detect_language(file_path)
+            language_obj = get_language(lang_name) if lang_name else None
+
+            for sym in syms:
+                caller_key = f"{sym.file_path}:{sym.name}"
+                if language_obj is not None:
+                    call_names = self._extract_calls_ast(
+                        sym.body, language_obj, callee_names, sym.name,
+                    )
+                else:
+                    # Fallback: regex heuristic for unsupported languages
+                    call_names = self._extract_calls_regex(
+                        sym.body, callee_names, sym.name,
+                    )
+
+                for callee_name in call_names:
+                    edge = CallEdge(
+                        caller=caller_key,
+                        callee=callee_name,
+                        file_path=sym.file_path,
+                        line=sym.start_line,
+                    )
+                    self._edges.append(edge)
+                    self._callers.setdefault(callee_name, []).append(edge)
+                    self._callees.setdefault(caller_key, []).append(edge)
+
+    # ----- AST-based extraction -----
+
+    def _extract_calls_ast(
+        self,
+        body: str,
+        language: tree_sitter.Language,
+        known_names: set[str],
+        self_name: str,
+    ) -> set[str]:
+        """Extract function/method call names from *body* via tree-sitter AST.
+
+        Returns the set of *known* callee names that appear as call
+        targets in the AST (excluding self-references).
+        """
+        source = body.encode("utf-8")
+        parser = tree_sitter.Parser(language)
+        tree = parser.parse(source)
+
+        found: set[str] = set()
+        self._walk_calls(tree.root_node, source, known_names, self_name, found)
+        return found
+
+    def _walk_calls(
+        self,
+        node: tree_sitter.Node,
+        source: bytes,
+        known_names: set[str],
+        self_name: str,
+        found: set[str],
+    ) -> None:
+        """Recursively walk the AST collecting call-target names."""
+        if node.type in self._CALL_NODE_TYPES:
+            name = self._resolve_call_name(node, source)
+            if name and name != self_name and name in known_names:
+                found.add(name)
+
+        for child in node.children:
+            self._walk_calls(child, source, known_names, self_name, found)
+
+    @staticmethod
+    def _resolve_call_name(call_node: tree_sitter.Node, source: bytes) -> str | None:
+        """Resolve the callee name from a call/call_expression node.
+
+        Handles:
+        - ``foo()``: direct identifier call
+        - ``obj.method()``: attribute/member access — returns ``method``
+        - ``pkg::func()``: scoped identifier (Rust/C++) — returns ``func``
+        """
+        # The function/target is typically the first named child
+        func = call_node.child_by_field_name("function")
+        if func is None:
+            # Java method_invocation uses "name" field
+            func = call_node.child_by_field_name("name")
+        if func is None and call_node.children:
+            func = call_node.children[0]
+        if func is None:
+            return None
+
+        # Drill through attribute access to get the final name
+        if func.type in ("attribute", "member_expression", "field_expression",
+                         "scoped_identifier", "member_access_expression"):
+            # The method name is the last named child / field "attribute"/"field"
+            attr = func.child_by_field_name("attribute") or func.child_by_field_name("field")
+            if attr is not None:
+                return source[attr.start_byte:attr.end_byte].decode("utf-8", errors="replace")
+            # Fallback: last named child
+            for ch in reversed(func.children):
+                if ch.is_named:
+                    return source[ch.start_byte:ch.end_byte].decode("utf-8", errors="replace")
+            return None
+
+        if func.type == "identifier":
+            return source[func.start_byte:func.end_byte].decode("utf-8", errors="replace")
+
+        return None
+
+    # ----- regex fallback -----
+
+    @staticmethod
+    def _extract_calls_regex(
+        body: str,
+        known_names: set[str],
+        self_name: str,
+    ) -> set[str]:
+        """Fallback regex heuristic for unsupported languages."""
+        found: set[str] = set()
+        for name in known_names:
+            if name == self_name:
+                continue
+            if re.search(r"\b" + re.escape(name) + r"\s*[\(\.]", body):
+                found.add(name)
+        return found
+
+    @property
+    def edges(self) -> list[CallEdge]:
+        """Return a shallow copy of all call-graph edges."""
+        return list(self._edges)
+
+    def callers_of(self, name: str) -> list[CallEdge]:
+        """Get all edges where `name` is the callee."""
+        return self._callers.get(name, [])
+
+    def callees_of(self, caller_key: str) -> list[CallEdge]:
+        """Get all edges where `caller_key` is the caller."""
+        return self._callees.get(caller_key, [])
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize the call graph to a summary dictionary."""
+        return {
+            "edges": [e.to_dict() for e in self._edges],
+            "node_count": len(
+                {e.caller for e in self._edges} | {e.callee for e in self._edges}
+            ),
+            "edge_count": len(self._edges),
+        }
+
+    def __repr__(self) -> str:
+        return f"CallGraph(edges={len(self._edges)})"
+
+
+# ---------------------------------------------------------------------------
+# Dependency Map (file-level imports)
+# ---------------------------------------------------------------------------
+
+@dataclass
+class FileDependency:
+    """A file-level dependency."""
+
+    source_file: str
+    import_text: str
+    line: int
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize the file dependency to a plain dictionary."""
+        return {
+            "source_file": self.source_file,
+            "import_text": self.import_text,
+            "line": self.line,
+        }
+
+
+class DependencyMap:
+    """Tracks file-level dependencies based on import statements."""
+
+    def __init__(self) -> None:
+        self._dependencies: dict[str, list[FileDependency]] = {}
+
+    def add_file(self, file_path: str, content: str | None = None) -> list[FileDependency]:
+        """Parse imports from a file and record as dependencies."""
+        imports = extract_imports(file_path, content)
+        deps: list[FileDependency] = []
+        for imp in imports:
+            dep = FileDependency(
+                source_file=file_path,
+                import_text=imp.body.strip(),
+                line=imp.start_line,
+            )
+            deps.append(dep)
+        self._dependencies[file_path] = deps
+        return deps
+
+    def get_dependencies(self, file_path: str) -> list[FileDependency]:
+        """Get dependencies for a specific file."""
+        return self._dependencies.get(file_path, [])
+
+    def get_all_files(self) -> list[str]:
+        """Get all tracked files."""
+        return list(self._dependencies.keys())
+
+    def get_dependents(self, module_name: str) -> list[FileDependency]:
+        """Find all files that import a given module name."""
+        results: list[FileDependency] = []
+        for deps in self._dependencies.values():
+            for dep in deps:
+                if module_name in dep.import_text:
+                    results.append(dep)
+        return results
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize all tracked file dependencies to a dictionary."""
+        return {
+            file: [d.to_dict() for d in deps]
+            for file, deps in self._dependencies.items()
+        }
+
+    def __repr__(self) -> str:
+        return f"DependencyMap(files={len(self._dependencies)})"