osscodeiq 0.0.0__py3-none-any.whl

osscodeiq/parsing/parser_manager.py

@@ -0,0 +1,125 @@
+"""Thread-safe tree-sitter parser pool manager."""
+
+from __future__ import annotations
+
+import logging
+import queue
+from typing import TYPE_CHECKING
+
+import tree_sitter
+
+from osscodeiq.parsing.languages.java import JavaLanguageSupport
+from osscodeiq.parsing.languages.python import PythonLanguageSupport
+from osscodeiq.parsing.languages.typescript import (
+    JavaScriptLanguageSupport,
+    TypeScriptLanguageSupport,
+)
+
+if TYPE_CHECKING:
+    from osscodeiq.discovery.file_discovery import DiscoveredFile
+    from osscodeiq.parsing.languages.base import LanguageSupport
+
+logger = logging.getLogger(__name__)
+
+# Default pool size per language.
+_DEFAULT_POOL_SIZE = 4
+
+
+class ParserManager:
+    """Manages a pool of tree-sitter parsers for thread-safe parsing."""
+
+    def __init__(self, pool_size: int = _DEFAULT_POOL_SIZE) -> None:
+        self._pool_size = pool_size
+        self._languages: dict[str, LanguageSupport] = {}
+        self._ts_languages: dict[str, tree_sitter.Language] = {}
+        self._pools: dict[str, queue.Queue[tree_sitter.Parser]] = {}
+        self._query_cache: dict[tuple[str, str], tree_sitter.Query] = {}
+
+        # Auto-register built-in languages.
+        self._register_builtins()
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def register_language(self, name: str, support: LanguageSupport) -> None:
+        """Register a language and pre-populate its parser pool."""
+        self._languages[name] = support
+        ts_lang = support.get_language()
+        self._ts_languages[name] = ts_lang
+        self._pools[name] = self._create_pool(ts_lang)
+
+    def parse_file(
+        self, file: DiscoveredFile, content: bytes
+    ) -> tree_sitter.Tree | None:
+        """Parse *content* using the parser for *file*'s language.
+
+        Borrows a parser from the pool and returns it afterwards, making
+        this method safe to call from multiple threads concurrently.
+        """
+        lang = file.language
+        pool = self._pools.get(lang)
+        if pool is None:
+            logger.debug("No parser registered for language %s", lang)
+            return None
+
+        parser = pool.get()
+        try:
+            return parser.parse(content)
+        finally:
+            pool.put(parser)
+
+    def get_query(
+        self, language: str, query_name: str
+    ) -> tree_sitter.Query | None:
+        """Return a compiled tree-sitter Query, cached after first build."""
+        cache_key = (language, query_name)
+        if cache_key in self._query_cache:
+            return self._query_cache[cache_key]
+
+        support = self._languages.get(language)
+        if support is None:
+            return None
+
+        queries = support.get_queries()
+        source = queries.get(query_name)
+        if source is None:
+            return None
+
+        ts_lang = self._ts_languages[language]
+        compiled = tree_sitter.Query(ts_lang, source)
+        self._query_cache[cache_key] = compiled
+        return compiled
+
+    # ------------------------------------------------------------------
+    # Internals
+    # ------------------------------------------------------------------
+
+    def _create_pool(
+        self, ts_lang: tree_sitter.Language
+    ) -> queue.Queue[tree_sitter.Parser]:
+        pool: queue.Queue[tree_sitter.Parser] = queue.Queue(
+            maxsize=self._pool_size
+        )
+        for _ in range(self._pool_size):
+            parser = tree_sitter.Parser(ts_lang)
+            pool.put(parser)
+        return pool
+
+    def _register_builtins(self) -> None:
+        """Register languages that ship with the package."""
+        builtins: list[LanguageSupport] = [
+            JavaLanguageSupport(),  # type: ignore[list-item]
+            PythonLanguageSupport(),  # type: ignore[list-item]
+            TypeScriptLanguageSupport(),  # type: ignore[list-item]
+            JavaScriptLanguageSupport(),  # type: ignore[list-item]
+        ]
+        for support in builtins:
+            try:
+                self.register_language(support.name, support)
+            except Exception:  # noqa: BLE001
+                logger.warning(
+                    "Failed to register built-in language %s",
+                    support.name,
+                    exc_info=True,
+                )

osscodeiq/parsing/structured/gradle_parser.py

@@ -0,0 +1,78 @@
+"""Regex-based Gradle build file parser."""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+# Patterns for Gradle dependency declarations.
+# Matches: implementation 'group:artifact:version'
+#          api "group:artifact:version"
+#          compile 'group:artifact:version'
+#          testImplementation("group:artifact:version")
+_DEP_CONFIGS = (
+    "implementation",
+    "api",
+    "compile",
+    "compileOnly",
+    "runtimeOnly",
+    "testImplementation",
+    "testCompile",
+    "testRuntimeOnly",
+    "annotationProcessor",
+    "kapt",
+)
+
+_DEP_PATTERN = re.compile(
+    r"(?P<config>"
+    + "|".join(_DEP_CONFIGS)
+    + r")\s*[\(\s]['\"](?P<coords>[^'\"]+)['\"]",
+    re.MULTILINE,
+)
+
+# Plugin patterns: id 'xxx' or id("xxx")
+_PLUGIN_PATTERN = re.compile(
+    r"""id\s*[\(\s]['"](?P<plugin>[^'"]+)['"]""",
+    re.MULTILINE,
+)
+
+# Group / version from the build file.
+_GROUP_PATTERN = re.compile(r"""group\s*=\s*['"](?P<group>[^'"]+)['"]""")
+_VERSION_PATTERN = re.compile(r"""version\s*=\s*['"](?P<version>[^'"]+)['"]""")
+
+
+class GradleParser:
+    """Extracts dependencies and metadata from ``build.gradle`` files."""
+
+    def parse(self, content: bytes, file_path: str) -> dict[str, Any]:
+        """Parse a Gradle build file and return structured data."""
+        text = content.decode("utf-8", errors="replace")
+
+        dependencies: list[dict[str, str]] = []
+        for m in _DEP_PATTERN.finditer(text):
+            config = m.group("config")
+            coords = m.group("coords")
+            parts = coords.split(":")
+            dep: dict[str, str] = {"configuration": config, "raw": coords}
+            if len(parts) >= 2:
+                dep["group"] = parts[0]
+                dep["artifact"] = parts[1]
+            if len(parts) >= 3:
+                dep["version"] = parts[2]
+            dependencies.append(dep)
+
+        plugins: list[str] = [
+            m.group("plugin") for m in _PLUGIN_PATTERN.finditer(text)
+        ]
+
+        group_m = _GROUP_PATTERN.search(text)
+        version_m = _VERSION_PATTERN.search(text)
+
+        return {
+            "type": "gradle",
+            "file": file_path,
+            "group": group_m.group("group") if group_m else None,
+            "version": version_m.group("version") if version_m else None,
+            "plugins": plugins,
+            "dependencies": dependencies,
+        }

osscodeiq/parsing/structured/json_parser.py

@@ -0,0 +1,24 @@
+"""JSON structured file parser."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+
+class JsonParser:
+    """Parses JSON files into structured dictionaries."""
+
+    def parse(self, content: bytes, file_path: str) -> dict[str, Any]:
+        """Parse *content* as JSON and return a structured dict."""
+        try:
+            text = content.decode("utf-8", errors="replace")
+            data = json.loads(text)
+        except (json.JSONDecodeError, UnicodeDecodeError) as exc:
+            return {"error": "invalid_json", "file": file_path, "detail": str(exc)}
+
+        return {
+            "type": "json",
+            "file": file_path,
+            "data": data,
+        }

osscodeiq/parsing/structured/properties_parser.py

@@ -0,0 +1,56 @@
+"""Java .properties file parser."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+class PropertiesParser:
+    """Parses Java-style ``.properties`` files into structured dicts."""
+
+    def parse(self, content: bytes, file_path: str) -> dict[str, Any]:
+        """Parse key=value property entries.
+
+        Handles ``=`` and ``:`` separators, comment lines (``#``, ``!``),
+        blank lines, and continuation lines ending with ``\\``.
+        """
+        text = content.decode("utf-8", errors="replace")
+        properties: dict[str, str] = {}
+
+        logical_line = ""
+        for raw_line in text.splitlines():
+            # Handle continuation lines
+            if logical_line:
+                raw_line = raw_line.lstrip()
+            logical_line += raw_line
+
+            if logical_line.endswith("\\"):
+                logical_line = logical_line[:-1]
+                continue
+
+            line = logical_line.strip()
+            logical_line = ""
+
+            if not line or line.startswith("#") or line.startswith("!"):
+                continue
+
+            # Split on first unescaped = or :
+            sep_idx = -1
+            for i, ch in enumerate(line):
+                if ch in ("=", ":") and (i == 0 or line[i - 1] != "\\"):
+                    sep_idx = i
+                    break
+
+            if sep_idx == -1:
+                # Treat the whole line as a key with empty value
+                properties[line] = ""
+            else:
+                key = line[:sep_idx].rstrip()
+                value = line[sep_idx + 1 :].lstrip()
+                properties[key] = value
+
+        return {
+            "type": "properties",
+            "file": file_path,
+            "data": properties,
+        }

osscodeiq/parsing/structured/sql_parser.py

@@ -0,0 +1,54 @@
+"""SQL migration file parser using sqlparse."""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+import sqlparse
+
+
+class SqlParser:
+    """Parses SQL migration files (Flyway, Liquibase) to extract DDL statements."""
+
+    _TABLE_NAME_RE = re.compile(
+        r"(?:CREATE|ALTER|DROP)\s+TABLE\s+(?:IF\s+(?:NOT\s+)?EXISTS\s+)?[`\"]?(\w+)[`\"]?",
+        re.IGNORECASE,
+    )
+
+    def parse(self, content: bytes, file_path: str) -> dict[str, Any]:
+        """Parse SQL content and extract DDL information."""
+        text = content.decode("utf-8", errors="replace")
+        statements = sqlparse.parse(text)
+
+        tables_created: list[str] = []
+        tables_altered: list[str] = []
+        tables_dropped: list[str] = []
+        raw_statements: list[str] = []
+
+        for stmt in statements:
+            stmt_text = str(stmt).strip()
+            if not stmt_text:
+                continue
+
+            stmt_type = stmt.get_type()
+            raw_statements.append(stmt_text)
+
+            for match in self._TABLE_NAME_RE.finditer(stmt_text):
+                table_name = match.group(1)
+                upper = stmt_text.upper().lstrip()
+                if upper.startswith("CREATE"):
+                    tables_created.append(table_name)
+                elif upper.startswith("ALTER"):
+                    tables_altered.append(table_name)
+                elif upper.startswith("DROP"):
+                    tables_dropped.append(table_name)
+
+        return {
+            "type": "sql",
+            "file": file_path,
+            "tables_created": tables_created,
+            "tables_altered": tables_altered,
+            "tables_dropped": tables_dropped,
+            "statement_count": len(raw_statements),
+        }

osscodeiq/parsing/structured/xml_parser.py

@@ -0,0 +1,148 @@
+"""XML structured file parser with special handling for Maven and Spring."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from lxml import etree
+
+
+class XmlParser:
+    """Parses XML files into structured dictionaries.
+
+    Provides specialised extraction for:
+    - Maven ``pom.xml`` (groupId, artifactId, dependencies, modules)
+    - Spring XML configuration (beans, component-scan)
+    """
+
+    def parse(self, content: bytes, file_path: str) -> dict[str, Any]:
+        """Parse *content* and return a structured dict."""
+        try:
+            parser = etree.XMLParser(resolve_entities=False, no_network=True)
+            root = etree.fromstring(content, parser)
+        except etree.XMLSyntaxError:
+            return {"error": "invalid_xml", "file": file_path}
+
+        file_lower = file_path.rsplit("/", 1)[-1].lower()
+
+        if file_lower == "pom.xml":
+            return self._parse_pom(root, file_path)
+
+        # Detect Spring XML config by namespace or root tag.
+        root_tag = etree.QName(root.tag).localname if root.tag else ""
+        ns = root.nsmap.get(None, "")
+        if root_tag == "beans" or "springframework" in ns:
+            return self._parse_spring_xml(root, file_path)
+
+        # Generic XML: return tag tree summary.
+        return {
+            "type": "xml",
+            "file": file_path,
+            "root_tag": root_tag,
+            "namespaces": dict(root.nsmap),
+        }
+
+    # ------------------------------------------------------------------
+    # Maven POM parsing
+    # ------------------------------------------------------------------
+
+    def _parse_pom(
+        self, root: etree._Element, file_path: str
+    ) -> dict[str, Any]:
+        ns = root.nsmap.get(None, "")
+        prefix = f"{{{ns}}}" if ns else ""
+
+        def _text(parent: etree._Element, tag: str) -> str | None:
+            el = parent.find(f"{prefix}{tag}")
+            return el.text.strip() if el is not None and el.text else None
+
+        group_id = _text(root, "groupId")
+        artifact_id = _text(root, "artifactId")
+        version = _text(root, "version")
+        packaging = _text(root, "packaging")
+
+        # Parent info
+        parent_el = root.find(f"{prefix}parent")
+        parent: dict[str, str | None] | None = None
+        if parent_el is not None:
+            parent = {
+                "groupId": _text(parent_el, "groupId"),
+                "artifactId": _text(parent_el, "artifactId"),
+                "version": _text(parent_el, "version"),
+            }
+            if group_id is None:
+                group_id = parent.get("groupId")
+
+        # Dependencies
+        deps: list[dict[str, str | None]] = []
+        deps_el = root.find(f"{prefix}dependencies")
+        if deps_el is not None:
+            for dep in deps_el.findall(f"{prefix}dependency"):
+                deps.append(
+                    {
+                        "groupId": _text(dep, "groupId"),
+                        "artifactId": _text(dep, "artifactId"),
+                        "version": _text(dep, "version"),
+                        "scope": _text(dep, "scope"),
+                    }
+                )
+
+        # Modules
+        modules: list[str] = []
+        modules_el = root.find(f"{prefix}modules")
+        if modules_el is not None:
+            for mod in modules_el.findall(f"{prefix}module"):
+                if mod.text:
+                    modules.append(mod.text.strip())
+
+        return {
+            "type": "pom",
+            "file": file_path,
+            "groupId": group_id,
+            "artifactId": artifact_id,
+            "version": version,
+            "packaging": packaging,
+            "parent": parent,
+            "dependencies": deps,
+            "modules": modules,
+        }
+
+    # ------------------------------------------------------------------
+    # Spring XML config parsing
+    # ------------------------------------------------------------------
+
+    def _parse_spring_xml(
+        self, root: etree._Element, file_path: str
+    ) -> dict[str, Any]:
+        ns = root.nsmap.get(None, "")
+        prefix = f"{{{ns}}}" if ns else ""
+
+        beans: list[dict[str, str | None]] = []
+        for bean in root.iter(f"{prefix}bean"):
+            beans.append(
+                {
+                    "id": bean.get("id"),
+                    "class": bean.get("class"),
+                    "scope": bean.get("scope"),
+                }
+            )
+
+        # context:component-scan
+        component_scans: list[str] = []
+        ctx_ns = None
+        for pfx, uri in root.nsmap.items():
+            if "context" in (uri or ""):
+                ctx_ns = uri
+                break
+        if ctx_ns:
+            for scan in root.iter(f"{{{ctx_ns}}}component-scan"):
+                pkg = scan.get("base-package")
+                if pkg:
+                    component_scans.append(pkg)
+
+        return {
+            "type": "spring_xml",
+            "file": file_path,
+            "beans": beans,
+            "component_scans": component_scans,
+        }

osscodeiq/parsing/structured/yaml_parser.py

@@ -0,0 +1,38 @@
+"""YAML structured file parser with multi-document support."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import yaml
+
+
+class YamlParser:
+    """Parses YAML files into structured dictionaries."""
+
+    def parse(self, content: bytes, file_path: str) -> dict[str, Any]:
+        """Parse *content* as YAML.
+
+        Supports multi-document YAML files (``---`` separators). When
+        multiple documents are present the result contains a ``documents``
+        list; single-document files return the document directly under a
+        ``data`` key.
+        """
+        try:
+            text = content.decode("utf-8", errors="replace")
+            docs = list(yaml.safe_load_all(text))
+        except yaml.YAMLError as exc:
+            return {"error": "invalid_yaml", "file": file_path, "detail": str(exc)}
+
+        if len(docs) == 1:
+            return {
+                "type": "yaml",
+                "file": file_path,
+                "data": docs[0],
+            }
+
+        return {
+            "type": "yaml_multi",
+            "file": file_path,
+            "documents": docs,
+        }

osscodeiq/server/__init__.py

@@ -0,0 +1,7 @@
+"""OSSCodeIQ server — unified REST API + MCP on a single port."""
+
+from __future__ import annotations
+
+from osscodeiq.server.app import create_app
+
+__all__ = ["create_app"]

osscodeiq/server/app.py

@@ -0,0 +1,53 @@
+"""FastAPI application assembly — mounts REST API, MCP server, and welcome page."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from fastapi import FastAPI
+from fastapi.responses import HTMLResponse
+
+from osscodeiq.server.middleware import AuthMiddleware
+from osscodeiq.server.mcp_server import get_mcp_app, set_service
+from osscodeiq.server.routes import create_router
+from osscodeiq.server.service import CodeIQService
+
+
+def create_app(
+    codebase_path: Path = Path("."),
+    backend: str = "networkx",
+    config_path: Path | None = None,
+) -> FastAPI:
+    """Create and configure the unified OSSCodeIQ server."""
+    service = CodeIQService(
+        path=codebase_path, backend=backend, config_path=config_path
+    )
+
+    # Set up MCP server
+    set_service(service)
+    mcp_app = get_mcp_app()
+
+    # Create FastAPI with MCP lifespan
+    app = FastAPI(
+        title="OSSCodeIQ",
+        description="OSSCodeIQ — graph queries, flow diagrams, and codebase analysis",
+        lifespan=mcp_app.lifespan,
+    )
+
+    # Auth middleware stub (no-op, ready for future auth)
+    app.add_middleware(AuthMiddleware)
+
+    # Mount MCP at /mcp (streamable HTTP)
+    app.mount("/mcp", mcp_app)
+
+    # Include REST routes at /api
+    router = create_router(service)
+    app.include_router(router)
+
+    # Welcome page at /
+    @app.get("/", response_class=HTMLResponse, include_in_schema=False)
+    async def welcome():
+        template_path = Path(__file__).parent / "templates" / "welcome.html"
+        return HTMLResponse(template_path.read_text(encoding="utf-8"))
+
+    return app