codexa 0.4.0__py3-none-any.whl

semantic_code_intelligence/parsing/parser.py

@@ -0,0 +1,375 @@
+"""Code parser — uses tree-sitter to extract functions, classes, and symbols."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import tree_sitter
+
+from semantic_code_intelligence.utils.logging import get_logger
+
+logger = get_logger("parsing")
+
+# Grammar modules for supported languages
+_LANGUAGE_MODULES: dict[str, str] = {
+    "python": "tree_sitter_python",
+    "javascript": "tree_sitter_javascript",
+    "typescript": "tree_sitter_typescript",
+    "tsx": "tree_sitter_typescript",
+    "java": "tree_sitter_java",
+    "go": "tree_sitter_go",
+    "rust": "tree_sitter_rust",
+    "cpp": "tree_sitter_cpp",
+    "csharp": "tree_sitter_c_sharp",
+    "ruby": "tree_sitter_ruby",
+    "php": "tree_sitter_php",
+}
+
+# Languages that require a special factory function name (not just `language()`)
+_LANGUAGE_FACTORY: dict[str, str] = {
+    "typescript": "language_typescript",
+    "tsx": "language_tsx",
+    "php": "language_php",
+}
+
+# Extension to language mapping
+EXTENSION_TO_LANGUAGE: dict[str, str] = {
+    ".py": "python",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".ts": "typescript",
+    ".tsx": "tsx",
+    ".java": "java",
+    ".go": "go",
+    ".rs": "rust",
+    ".cpp": "cpp",
+    ".cc": "cpp",
+    ".hpp": "cpp",
+    ".h": "cpp",
+    ".cs": "csharp",
+    ".rb": "ruby",
+    ".php": "php",
+}
+
+# Node types that represent function definitions per language
+FUNCTION_NODE_TYPES: dict[str, set[str]] = {
+    "python": {"function_definition"},
+    "javascript": {"function_declaration", "arrow_function", "method_definition"},
+    "typescript": {"function_declaration", "arrow_function", "method_definition"},
+    "tsx": {"function_declaration", "arrow_function", "method_definition"},
+    "java": {"method_declaration", "constructor_declaration"},
+    "go": {"function_declaration", "method_declaration"},
+    "rust": {"function_item"},
+    "cpp": {"function_definition"},
+    "csharp": {"method_declaration", "constructor_declaration"},
+    "ruby": {"method", "singleton_method"},
+    "php": {"function_definition", "method_declaration"},
+}
+
+# Node types that represent class/struct definitions per language
+CLASS_NODE_TYPES: dict[str, set[str]] = {
+    "python": {"class_definition"},
+    "javascript": {"class_declaration"},
+    "typescript": {"class_declaration", "interface_declaration", "enum_declaration"},
+    "tsx": {"class_declaration", "interface_declaration", "enum_declaration"},
+    "java": {"class_declaration", "interface_declaration", "enum_declaration"},
+    "go": {"type_declaration"},
+    "rust": {"struct_item", "enum_item", "impl_item", "trait_item"},
+    "cpp": {"class_specifier", "struct_specifier", "enum_specifier"},
+    "csharp": {"class_declaration", "interface_declaration", "struct_declaration", "enum_declaration"},
+    "ruby": {"class", "module"},
+    "php": {"class_declaration", "interface_declaration", "trait_declaration", "enum_declaration"},
+}
+
+# Node types for import statements
+IMPORT_NODE_TYPES: dict[str, set[str]] = {
+    "python": {"import_statement", "import_from_statement"},
+    "javascript": {"import_statement"},
+    "typescript": {"import_statement"},
+    "tsx": {"import_statement"},
+    "java": {"import_declaration"},
+    "go": {"import_declaration"},
+    "rust": {"use_declaration"},
+    "cpp": {"preproc_include"},
+    "csharp": {"using_directive"},
+    "ruby": {"call"},  # require/require_relative detected via name filter
+    "php": {"namespace_use_declaration"},
+}
+
+# Cache for loaded languages
+_language_cache: dict[str, tree_sitter.Language] = {}
+
+
+@dataclass
+class Symbol:
+    """A parsed symbol (function, class, method, etc.)."""
+
+    name: str
+    kind: str  # "function", "class", "method", "import"
+    file_path: str
+    start_line: int
+    end_line: int
+    start_col: int
+    end_col: int
+    body: str
+    parent: str | None = None  # Parent class name for methods
+    parameters: list[str] = field(default_factory=list)
+    decorators: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to a JSON-serializable dictionary."""
+        return {
+            "name": self.name,
+            "kind": self.kind,
+            "file_path": self.file_path,
+            "start_line": self.start_line,
+            "end_line": self.end_line,
+            "body": self.body,
+            "parent": self.parent,
+            "parameters": self.parameters,
+            "decorators": self.decorators,
+        }
+
+
+def get_language(lang_name: str) -> tree_sitter.Language | None:
+    """Load and cache a tree-sitter Language for the given language name.
+
+    Args:
+        lang_name: Language name (e.g. 'python', 'javascript').
+
+    Returns:
+        A tree_sitter.Language instance, or None if unsupported.
+    """
+    if lang_name in _language_cache:
+        return _language_cache[lang_name]
+
+    module_name = _LANGUAGE_MODULES.get(lang_name)
+    if module_name is None:
+        return None
+
+    try:
+        import importlib
+        mod = importlib.import_module(module_name)
+        factory_name = _LANGUAGE_FACTORY.get(lang_name, "language")
+        factory = getattr(mod, factory_name)
+        lang = tree_sitter.Language(factory())
+        _language_cache[lang_name] = lang
+        return lang
+    except (ImportError, AttributeError, Exception) as e:
+        logger.warning("Failed to load tree-sitter grammar for %s: %s", lang_name, e)
+        return None
+
+
+def detect_language(file_path: str) -> str | None:
+    """Detect language from file extension.
+
+    Returns None if the language is not supported by tree-sitter.
+    """
+    ext = Path(file_path).suffix.lower()
+    return EXTENSION_TO_LANGUAGE.get(ext)
+
+
+def _get_node_text(node: tree_sitter.Node, source: bytes) -> str:
+    """Extract the text of a tree-sitter node."""
+    return source[node.start_byte:node.end_byte].decode("utf-8", errors="replace")
+
+
+def _find_name(node: tree_sitter.Node, source: bytes) -> str:
+    """Find the name identifier within a definition node."""
+    _NAME_TYPES = {
+        "identifier", "property_identifier", "type_identifier",
+        "field_identifier", "constant", "name",  # constant=Ruby, name=PHP
+    }
+    for child in node.children:
+        if child.type in _NAME_TYPES:
+            return _get_node_text(child, source)
+    # C++: name may be inside a declarator child (e.g. function_declarator)
+    for child in node.children:
+        if child.type.endswith("_declarator"):
+            for sub in child.children:
+                if sub.type in _NAME_TYPES:
+                    return _get_node_text(sub, source)
+    return "<anonymous>"
+
+
+def _find_parameters(node: tree_sitter.Node, source: bytes) -> list[str]:
+    """Extract parameter names from a function definition node."""
+    params: list[str] = []
+    for child in node.children:
+        if child.type in ("parameters", "formal_parameters", "parameter_list"):
+            for param in child.children:
+                if param.type in ("identifier", "typed_parameter", "typed_default_parameter"):
+                    # For typed params, get just the name
+                    name_node = param.child_by_field_name("name") or param
+                    for sub in [name_node] if name_node.type == "identifier" else name_node.children:
+                        if sub.type == "identifier":
+                            params.append(_get_node_text(sub, source))
+                            break
+                elif param.type == "parameter":
+                    for sub in param.children:
+                        if sub.type == "identifier":
+                            params.append(_get_node_text(sub, source))
+                            break
+    return params
+
+
+def _find_decorators(node: tree_sitter.Node, source: bytes) -> list[str]:
+    """Extract decorator names from a definition node (Python)."""
+    decorators: list[str] = []
+    if node.prev_named_sibling and node.prev_named_sibling.type == "decorator":
+        decorators.append(_get_node_text(node.prev_named_sibling, source).strip())
+    # Also check for decorated_definition parent
+    if node.parent and node.parent.type == "decorated_definition":
+        for child in node.parent.children:
+            if child.type == "decorator":
+                decorators.append(_get_node_text(child, source).strip())
+    return decorators
+
+
+def _extract_symbols_recursive(
+    node: tree_sitter.Node,
+    source: bytes,
+    file_path: str,
+    language: str,
+    parent_class: str | None = None,
+) -> list[Symbol]:
+    """Recursively walk the AST and extract symbols."""
+    symbols: list[Symbol] = []
+    func_types = FUNCTION_NODE_TYPES.get(language, set())
+    class_types = CLASS_NODE_TYPES.get(language, set())
+    import_types = IMPORT_NODE_TYPES.get(language, set())
+
+    for child in node.children:
+        # Handle decorated definitions (Python wraps func/class in decorated_definition)
+        actual = child
+        if child.type == "decorated_definition":
+            for sub in child.children:
+                if sub.type in func_types or sub.type in class_types:
+                    actual = sub
+                    break
+
+        if actual.type in func_types:
+            name = _find_name(actual, source)
+            # Some languages have dedicated method node types (e.g. Go method_declaration,
+            # JS method_definition) that indicate a method even without a parent class.
+            _method_node_types = {
+                "method_declaration", "method_definition", "constructor_declaration",
+            }
+            if parent_class or actual.type in _method_node_types:
+                kind = "method"
+            else:
+                kind = "function"
+            symbols.append(
+                Symbol(
+                    name=name,
+                    kind=kind,
+                    file_path=file_path,
+                    start_line=actual.start_point[0] + 1,
+                    end_line=actual.end_point[0] + 1,
+                    start_col=actual.start_point[1],
+                    end_col=actual.end_point[1],
+                    body=_get_node_text(actual, source),
+                    parent=parent_class,
+                    parameters=_find_parameters(actual, source),
+                    decorators=_find_decorators(actual, source),
+                )
+            )
+
+        elif actual.type in class_types:
+            name = _find_name(actual, source)
+            symbols.append(
+                Symbol(
+                    name=name,
+                    kind="class",
+                    file_path=file_path,
+                    start_line=actual.start_point[0] + 1,
+                    end_line=actual.end_point[0] + 1,
+                    start_col=actual.start_point[1],
+                    end_col=actual.end_point[1],
+                    body=_get_node_text(actual, source),
+                )
+            )
+            # Recurse into class body for methods
+            symbols.extend(
+                _extract_symbols_recursive(actual, source, file_path, language, parent_class=name)
+            )
+            continue  # already recursed into children
+
+        elif actual.type in import_types:
+            text = _get_node_text(actual, source).strip()
+            # Ruby: only treat require/require_relative calls as imports
+            if language == "ruby" and actual.type == "call":
+                method_name = _find_name(actual, source)
+                if method_name not in ("require", "require_relative"):
+                    symbols.extend(
+                        _extract_symbols_recursive(child, source, file_path, language, parent_class)
+                    )
+                    continue
+            symbols.append(
+                Symbol(
+                    name=text,
+                    kind="import",
+                    file_path=file_path,
+                    start_line=actual.start_point[0] + 1,
+                    end_line=actual.end_point[0] + 1,
+                    start_col=actual.start_point[1],
+                    end_col=actual.end_point[1],
+                    body=_get_node_text(actual, source),
+                )
+            )
+
+        # Recurse into children
+        symbols.extend(
+            _extract_symbols_recursive(child, source, file_path, language, parent_class)
+        )
+
+    return symbols
+
+
+def parse_file(file_path: str | Path, content: str | None = None) -> list[Symbol]:
+    """Parse a source file and extract all symbols.
+
+    Args:
+        file_path: Path to the source file.
+        content: Optional file content. If None, reads from disk.
+
+    Returns:
+        List of extracted Symbol objects.
+    """
+    file_path = str(file_path)
+    lang_name = detect_language(file_path)
+    if lang_name is None:
+        return []
+
+    language = get_language(lang_name)
+    if language is None:
+        return []
+
+    if content is None:
+        try:
+            content = Path(file_path).read_text(encoding="utf-8", errors="replace")
+        except (OSError, PermissionError):
+            return []
+
+    source = content.encode("utf-8")
+    parser = tree_sitter.Parser(language)
+    tree = parser.parse(source)
+
+    return _extract_symbols_recursive(tree.root_node, source, file_path, lang_name)
+
+
+def extract_functions(file_path: str | Path, content: str | None = None) -> list[Symbol]:
+    """Extract only function and method symbols from a file."""
+    return [s for s in parse_file(file_path, content) if s.kind in ("function", "method")]
+
+
+def extract_classes(file_path: str | Path, content: str | None = None) -> list[Symbol]:
+    """Extract only class symbols from a file."""
+    return [s for s in parse_file(file_path, content) if s.kind == "class"]
+
+
+def extract_imports(file_path: str | Path, content: str | None = None) -> list[Symbol]:
+    """Extract only import symbols from a file."""
+    return [s for s in parse_file(file_path, content) if s.kind == "import"]

semantic_code_intelligence/plugins/__init__.py

@@ -0,0 +1,255 @@
+"""Plugin architecture SDK — extensible hook system for CodexA.
+
+Provides:
+- PluginBase: abstract base class for plugins
+- PluginHook: enumeration of hook points
+- PluginManager: discovery, registration, and lifecycle management
+"""
+
+from __future__ import annotations
+
+import importlib
+import importlib.util
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+from semantic_code_intelligence.utils.logging import get_logger
+
+logger = get_logger("plugins")
+
+
+# ---------------------------------------------------------------------------
+# Hook Points
+# ---------------------------------------------------------------------------
+
+class PluginHook(str, Enum):
+    """Available hook points in the CodexA pipeline."""
+
+    # Indexing hooks
+    PRE_INDEX = "pre_index"
+    POST_INDEX = "post_index"
+    ON_CHUNK = "on_chunk"
+
+    # Search hooks
+    PRE_SEARCH = "pre_search"
+    POST_SEARCH = "post_search"
+
+    # Analysis hooks
+    PRE_ANALYSIS = "pre_analysis"
+    POST_ANALYSIS = "post_analysis"
+
+    # AI hooks
+    PRE_AI = "pre_ai"
+    POST_AI = "post_ai"
+
+    # File event hooks
+    ON_FILE_CHANGE = "on_file_change"
+
+    # Streaming hooks (Phase 12)
+    ON_STREAM = "on_stream"  # fired for streaming LLM token chunks
+
+    # Validation hooks (Phase 12)
+    CUSTOM_VALIDATION = "custom_validation"  # user-defined code validation rules
+
+    # Workflow intelligence hooks (Phase 18)
+    PRE_HOTSPOT_ANALYSIS = "pre_hotspot_analysis"
+    POST_HOTSPOT_ANALYSIS = "post_hotspot_analysis"
+    PRE_IMPACT_ANALYSIS = "pre_impact_analysis"
+    POST_IMPACT_ANALYSIS = "post_impact_analysis"
+    PRE_TRACE = "pre_trace"
+    POST_TRACE = "post_trace"
+
+    # AI Agent Tool Protocol hooks (Phase 19)
+    REGISTER_TOOL = "register_tool"
+    PRE_TOOL_INVOKE = "pre_tool_invoke"
+    POST_TOOL_INVOKE = "post_tool_invoke"
+
+    # Custom hooks
+    CUSTOM = "custom"
+
+
+# ---------------------------------------------------------------------------
+# Plugin Metadata
+# ---------------------------------------------------------------------------
+
+@dataclass
+class PluginMetadata:
+    """Metadata describing a plugin."""
+
+    name: str
+    version: str = "0.1.0"
+    description: str = ""
+    author: str = ""
+    hooks: list[PluginHook] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "name": self.name,
+            "version": self.version,
+            "description": self.description,
+            "author": self.author,
+            "hooks": [h.value for h in self.hooks],
+        }
+
+
+# ---------------------------------------------------------------------------
+# Plugin Base Class
+# ---------------------------------------------------------------------------
+
+class PluginBase(ABC):
+    """Abstract base class for CodexA plugins.
+
+    Subclass this and implement the required methods to create a plugin.
+    """
+
+    @abstractmethod
+    def metadata(self) -> PluginMetadata:
+        """Return metadata for this plugin."""
+        ...
+
+    def activate(self, context: dict[str, Any]) -> None:
+        """Called when the plugin is activated. Override for setup logic."""
+
+    def deactivate(self) -> None:
+        """Called when the plugin is deactivated. Override for cleanup logic."""
+
+    def on_hook(self, hook: PluginHook, data: dict[str, Any]) -> dict[str, Any]:
+        """Called when a registered hook fires.
+
+        Args:
+            hook: The hook that fired.
+            data: Hook-specific data dict. Plugin may modify and return it.
+
+        Returns:
+            Possibly modified data dict (passed to next plugin in chain).
+        """
+        return data
+
+
+# ---------------------------------------------------------------------------
+# Plugin Manager
+# ---------------------------------------------------------------------------
+
+class PluginManager:
+    """Manages plugin discovery, registration, and hook dispatch."""
+
+    def __init__(self) -> None:
+        self._plugins: dict[str, PluginBase] = {}
+        self._hook_registry: dict[PluginHook, list[str]] = {h: [] for h in PluginHook}
+        self._active: set[str] = set()
+
+    @property
+    def registered_plugins(self) -> list[str]:
+        return list(self._plugins.keys())
+
+    @property
+    def active_plugins(self) -> list[str]:
+        return list(self._active)
+
+    def register(self, plugin: PluginBase) -> None:
+        """Register a plugin instance."""
+        meta = plugin.metadata()
+        if meta.name in self._plugins:
+            logger.warning("Plugin '%s' already registered; replacing.", meta.name)
+        self._plugins[meta.name] = plugin
+        for hook in meta.hooks:
+            if meta.name not in self._hook_registry[hook]:
+                self._hook_registry[hook].append(meta.name)
+        logger.info("Registered plugin: %s v%s", meta.name, meta.version)
+
+    def unregister(self, name: str) -> None:
+        """Unregister a plugin by name."""
+        if name in self._active:
+            self.deactivate(name)
+        if name in self._plugins:
+            # Remove from hook registry
+            for hook in self._hook_registry:
+                if name in self._hook_registry[hook]:
+                    self._hook_registry[hook].remove(name)
+            del self._plugins[name]
+            logger.info("Unregistered plugin: %s", name)
+
+    def activate(self, name: str, context: dict[str, Any] | None = None) -> None:
+        """Activate a registered plugin."""
+        plugin = self._plugins.get(name)
+        if plugin is None:
+            raise ValueError(f"Plugin '{name}' is not registered.")
+        plugin.activate(context or {})
+        self._active.add(name)
+        logger.info("Activated plugin: %s", name)
+
+    def deactivate(self, name: str) -> None:
+        """Deactivate a plugin."""
+        plugin = self._plugins.get(name)
+        if plugin and name in self._active:
+            plugin.deactivate()
+            self._active.discard(name)
+            logger.info("Deactivated plugin: %s", name)
+
+    def dispatch(self, hook: PluginHook, data: dict[str, Any]) -> dict[str, Any]:
+        """Dispatch a hook to all active plugins registered for it.
+
+        Plugins are called in registration order. Each plugin receives
+        the data dict (possibly modified by the previous plugin).
+
+        Returns:
+            The final data dict after all plugins have processed it.
+        """
+        for name in self._hook_registry.get(hook, []):
+            if name not in self._active:
+                continue
+            plugin = self._plugins[name]
+            try:
+                data = plugin.on_hook(hook, data)
+            except Exception:
+                logger.exception("Plugin '%s' error on hook '%s'", name, hook.value)
+        return data
+
+    def get_plugin_info(self, name: str) -> dict[str, Any] | None:
+        """Get metadata for a specific plugin."""
+        plugin = self._plugins.get(name)
+        if plugin is None:
+            return None
+        meta = plugin.metadata()
+        info = meta.to_dict()
+        info["active"] = name in self._active
+        return info
+
+    def discover_from_directory(self, directory: Path) -> int:
+        """Discover and register plugins from a directory.
+
+        Looks for Python files with a `create_plugin()` factory function.
+
+        Returns:
+            Number of plugins discovered.
+        """
+        count = 0
+        if not directory.is_dir():
+            return 0
+
+        for py_file in sorted(directory.glob("*.py")):
+            if py_file.name.startswith("_"):
+                continue
+            try:
+                spec = importlib.util.spec_from_file_location(
+                    f"codex_plugin_{py_file.stem}", py_file
+                )
+                if spec is None or spec.loader is None:
+                    continue
+                module = importlib.util.module_from_spec(spec)
+                spec.loader.exec_module(module)
+
+                factory = getattr(module, "create_plugin", None)
+                if callable(factory):
+                    plugin = factory()
+                    if isinstance(plugin, PluginBase):
+                        self.register(plugin)
+                        count += 1
+            except Exception:
+                logger.exception("Failed to load plugin from %s", py_file)
+
+        logger.info("Discovered %d plugin(s) from %s", count, directory)
+        return count

semantic_code_intelligence/plugins/examples/__init__.py

@@ -0,0 +1 @@
+"""Sample plugins demonstrating the CodexA Plugin SDK."""