monorepoly 0.2.0__py3-none-any.whl

monorepoly/__init__.py

@@ -0,0 +1 @@
+"""Org-wide code and activity index for LLM agents."""

monorepoly/__main__.py

@@ -0,0 +1,161 @@
+"""Command line entry point: `monorepoly <command> [--debug]`."""
+
+import functools
+import importlib
+import logging
+import os
+import re
+from pathlib import Path
+from types import ModuleType
+from typing import TYPE_CHECKING
+
+from monorepoly import config, skill, wizard
+from monorepoly.exceptions import MonorepolyConfigError
+
+if TYPE_CHECKING:
+    from monorepoly.indexer import IndexContext
+
+_LOGGER = logging.getLogger(__name__)
+
+_CACHE_DIR = Path.home() / '.cache' / 'monorepoly'
+_DEFAULT_PORT = '8080'
+_BACKTICKED = re.compile(r'`([^`]*)`')
+_FALSE_WORDS = frozenset({'0', 'false', 'no'})
+_TRUE_WORDS = frozenset({'1', 'true', 'yes'})
+
+
+class _BacktickMarkupFormatter(logging.Formatter):
+    """Renders backticked log values as highlighted rich markup in the terminal."""
+
+    def format(self, record: logging.LogRecord) -> str:
+        from rich.markup import escape
+
+        # Escape first, so values cannot inject markup; escaping never touches backticks.
+        return _BACKTICKED.sub(r'[bold cyan]\1[/]', escape(super().format(record)))
+
+
+def _parse_flag(value: object) -> bool:
+    """Returns `value` as a bool, raising on anything but a bool or a known true/false word."""
+    # Fire turns `--flag=false` into the truthy string 'false'; only 'False' becomes a bool.
+    if isinstance(value, bool):
+        return value
+    word = value.lower() if isinstance(value, str) else None
+    if word in _TRUE_WORDS:
+        return True
+    if word in _FALSE_WORDS:
+        return False
+    raise MonorepolyConfigError(f"Expected a boolean flag value, got '{value}'!")
+
+
+class _Commands:
+    """Indexes the GitLab group and serves the index to agents."""
+
+    def __init__(self, debug: bool = False) -> None:
+        self._debug = debug
+
+    @functools.cached_property
+    def _settings(self) -> config.Settings:
+        # Lazy, so `install_skill` works before the indexer is configured.
+        return config.load_settings()
+
+    def install_skill(self, skills_dir: str = str(skill.SKILLS_DIR)) -> None:
+        """Installs the bundled Claude Code skill, replacing an older copy."""
+        skill.install_skill(dry_run=self._debug, skills_dir=Path(skills_dir))
+
+    def setup(self, server_url: str = '', client_id: str = '') -> None:
+        """Registers the server in Claude Code: hosted with `--server_url`, else prompts locally."""
+        from rich.console import Console
+
+        if server_url:
+            wizard.run_hosted(
+                client_id=client_id, console=Console(), dry_run=self._debug, server_url=server_url
+            )
+            return
+        # A local setup checks MongoDB, GitLab and Google credentials, and registers `serve`.
+        _load('mcp_server', extra='server')
+        wizard.run(console=Console(), dry_run=self._debug)
+
+    def index_org(self, include_archived: bool | str = False) -> None:
+        """Indexes every project in GITLAB_GROUP_ID, archived ones only if asked."""
+        indexer = _load('indexer', extra='indexer')
+        indexer.index_org(
+            ctx=self._index_context(),
+            group_id=self._settings.gitlab_group_id,
+            include_archived=_parse_flag(include_archived),
+        )
+
+    def index_project(self, path: str) -> None:
+        """Indexes the code and history of one `group/project`."""
+        indexer = _load('indexer', extra='indexer')
+        ctx = self._index_context()
+        ctx.store.ensure_indexes()
+        indexer.index_project(ctx=ctx, project=ctx.gitlab.project(path))
+
+    def sync_activity(self, path: str) -> None:
+        """Syncs issues, merge requests and discussions of one `group/project`."""
+        indexer = _load('indexer', extra='indexer')
+        ctx = self._index_context()
+        ctx.store.ensure_indexes()
+        indexer.sync_activity(ctx=ctx, project=ctx.gitlab.project(path))
+
+    def serve(self) -> None:
+        """Runs the MCP server on stdio."""
+        _load('mcp_server', extra='server').serve(self._settings)
+
+    def serve_http(self) -> None:
+        """Runs the hosted MCP server on HTTP for GitLab OAuth users, on port PORT."""
+        # Cloud Run tells the container its port in PORT.
+        port = int(os.environ.get('PORT', _DEFAULT_PORT))
+        hosted = _load('hosted', extra='server')
+        hosted.serve_http(port=port, settings=config.load_server_settings())
+
+    def _index_context(self) -> IndexContext:
+        settings = self._settings
+        modules = ('embed', 'gitlab', 'indexer', 'judge', 'licensing', 'store')
+        embed, gitlab, indexer, judge, licensing, store = (
+            _load(name, extra='indexer') for name in modules
+        )
+        return indexer.IndexContext(
+            cache_dir=_CACHE_DIR,
+            embedder=embed.make_embedder(project=settings.google_cloud_project),
+            gitlab=gitlab.make_gitlab(token=settings.gitlab_token, url=settings.gitlab_url),
+            gitlab_token=settings.gitlab_token,
+            judge=judge.make_judge(),
+            license=licensing.from_environ(os.environ),
+            # `debug` is a dry run: everything is computed, nothing is written.
+            store=store.Store(
+                db=store.connect(db=settings.mongodb_db, uri=settings.mongodb_uri),
+                dry_run=self._debug,
+            ),
+        )
+
+
+def _load(module: str, *, extra: str) -> ModuleType:
+    """Returns `monorepoly.<module>`, or says which extra installs what it is missing."""
+    try:
+        return importlib.import_module(f'monorepoly.{module}')
+    except ModuleNotFoundError as err:
+        if (err.name or '').startswith('monorepoly'):
+            raise
+        raise MonorepolyConfigError(
+            f'`{err.name}` is missing, install the `{extra}` extra:'
+            f" pip install 'monorepoly[{extra}]'"
+        ) from err
+
+
+def main() -> None:
+    import fire
+    from rich.console import Console
+    from rich.logging import RichHandler
+
+    # stdout carries the MCP protocol in `serve`, so all logging goes to stderr.
+    handler = RichHandler(console=Console(stderr=True), markup=True)
+    handler.setFormatter(_BacktickMarkupFormatter())
+    logging.basicConfig(handlers=[handler], level=logging.WARNING)
+    # Only our own progress at INFO: the SDKs and their HTTP clients log every request there.
+    logging.getLogger('monorepoly').setLevel(logging.INFO)
+    fire.Fire(_Commands)
+
+
+if __name__ == '__main__':
+    main()

monorepoly/access.py

@@ -0,0 +1,100 @@
+"""Who is asking, and which projects and confidential items they may see."""
+
+import dataclasses
+import logging
+
+from monorepoly.gitlab import GitLab
+from monorepoly.models import Project
+
+_LOGGER = logging.getLogger(__name__)
+
+_ENABLED = 'enabled'  # Feature access level: readable by anyone who can see the project.
+_NO_PROJECT = 0  # GitLab ids start at 1; Atlas `$vectorSearch.filter` rejects an empty `$in`.
+_OPEN = ('internal', 'public')  # Visibilities where non-members can see the project.
+_REPORTER = 20  # GitLab access level.
+
+
+def _ids(ids: frozenset[int]) -> list[int]:
+    return sorted(ids) or [_NO_PROJECT]
+
+
+def _readable(*, level: str, project: Project, reporter_ids: frozenset[int]) -> bool:
+    # Fail closed: a members-only feature counts as Reporter-only, since a non-member who sees
+    # an internal project looks the same to us as a Guest member.
+    return project.id in reporter_ids or level == _ENABLED
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Access:
+    code_project_ids: frozenset[int]
+    driver_emails: frozenset[str]
+    driver_id: int
+    issue_project_ids: frozenset[int]
+    merge_request_project_ids: frozenset[int]
+    project_ids: frozenset[int]
+    reporter_project_ids: frozenset[int]
+
+    def symbol_filter(self) -> dict:
+        """Returns the filter for symbols; code is readable only where GitLab shows it."""
+        # An empty set matches nothing: no access means no results.
+        return {'project_id': {'$in': _ids(self.code_project_ids)}}
+
+    def activity_filter(self) -> dict:
+        """Returns the filter for activity, kind-aware: each kind needs its GitLab feature."""
+        in_issues = {'project_id': {'$in': _ids(self.issue_project_ids)}}
+        in_code = self.symbol_filter()
+        in_merge_requests = {'project_id': {'$in': _ids(self.merge_request_project_ids)}}
+        # Confidential items need Reporter or above.
+        visible = {
+            '$or': [
+                {'confidential': False},
+                {'project_id': {'$in': _ids(self.reporter_project_ids)}},
+            ]
+        }
+        return {
+            '$or': [
+                {'$and': [{'kind': 'issue'}, in_issues, visible]},
+                {'$and': [{'kind': 'discussion', 'parent_kind': 'issue'}, in_issues, visible]},
+                {'$and': [{'kind': {'$in': ['branch', 'commit']}}, in_code]},
+                {'$and': [{'kind': 'merge_request'}, in_merge_requests]},
+                {
+                    '$and': [
+                        {'kind': 'discussion', 'parent_kind': 'merge_request'},
+                        in_merge_requests,
+                        visible,
+                    ]
+                },
+            ]
+        }
+
+
+def load_access(*, gitlab: GitLab, group_id: int | str) -> Access:
+    """Returns the token user's access; raises if GitLab rejects the token."""
+    user = gitlab.current_user()
+    projects = gitlab.group_projects(group_id=group_id)
+    reporter_ids = frozenset(
+        p.id for p in gitlab.group_projects(group_id=group_id, min_access_level=_REPORTER)
+    )
+
+    # Guests on private projects cannot read code, commits or merge requests.
+    code_ids = reporter_ids | {
+        p.id for p in projects if p.visibility in _OPEN and p.repository_access_level == _ENABLED
+    }
+    return Access(
+        code_project_ids=code_ids,
+        driver_emails=frozenset(email.lower() for email in user.emails),
+        driver_id=user.id,
+        issue_project_ids=frozenset(
+            p.id
+            for p in projects
+            if _readable(level=p.issues_access_level, project=p, reporter_ids=reporter_ids)
+        ),
+        merge_request_project_ids=frozenset(
+            p.id
+            for p in projects
+            if p.id in code_ids
+            and _readable(level=p.merge_requests_access_level, project=p, reporter_ids=reporter_ids)
+        ),
+        project_ids=frozenset(p.id for p in projects),
+        reporter_project_ids=reporter_ids,
+    )

monorepoly/chunk.py

@@ -0,0 +1,136 @@
+"""Splits Python source into module, class, function and method symbols."""
+
+import ast
+import logging
+import re
+import warnings
+from collections.abc import Iterator, Sequence
+
+from monorepoly.models import Symbol, SymbolKind
+
+_LOGGER = logging.getLogger(__name__)
+
+_FILE_KINDS = frozenset({SymbolKind.CONFIG_FILE, SymbolKind.MODULE})
+
+
+def chunk_python(*, path: str, project_id: int, ref: str, source: str) -> list[Symbol]:
+    """Returns the module symbol followed by its definitions, or nothing if unparsable."""
+    try:
+        with warnings.catch_warnings():
+            # Old code is full of invalid escapes; they are not our problem.
+            warnings.simplefilter('ignore', SyntaxWarning)
+            tree = ast.parse(source, filename=path)
+    except (SyntaxError, ValueError) as err:
+        _LOGGER.warning("Skipping unparsable '%s' in project %s: %s", path, project_id, err)
+        return []
+    lines = re.split(r'\r\n|\r|\n', source)
+    # Drop trailing empty element to keep module.end_line == len(lines).
+    if lines and lines[-1] == '':
+        lines.pop()
+    module = _module_name(path)
+    symbols = [
+        Symbol(
+            docstring=ast.get_docstring(tree),
+            end_line=max(len(lines), 1),
+            kind=SymbolKind.MODULE,
+            path=path,
+            project_id=project_id,
+            qualname=module,
+            ref=ref,
+            signature=f'module {module}',
+            source=source,
+            start_line=1,
+        )
+    ]
+    symbols.extend(
+        _walk(
+            body=tree.body,
+            in_class=False,
+            lines=lines,
+            path=path,
+            prefix=module,
+            project_id=project_id,
+            ref=ref,
+        )
+    )
+    return symbols
+
+
+def touched_symbols(
+    *,
+    line_ranges: Sequence[tuple[int, int]],
+    symbols: Sequence[Symbol],
+) -> list[Symbol]:
+    """Returns non-file symbols overlapping `line_ranges`, else the file symbol."""
+    hits = [
+        symbol
+        for symbol in symbols
+        if symbol.kind not in _FILE_KINDS
+        and any(start <= symbol.end_line and symbol.start_line <= end for start, end in line_ranges)
+    ]
+    if hits or not line_ranges:
+        return hits
+    return [symbol for symbol in symbols if symbol.kind in _FILE_KINDS]
+
+
+def _walk(
+    *,
+    body: list[ast.stmt],
+    in_class: bool,
+    lines: list[str],
+    path: str,
+    prefix: str,
+    project_id: int,
+    ref: str,
+) -> Iterator[Symbol]:
+    for node in body:
+        match node:
+            case ast.ClassDef():
+                kind, signature = SymbolKind.CLASS, _class_signature(node)
+            case ast.FunctionDef() | ast.AsyncFunctionDef():
+                kind = SymbolKind.METHOD if in_class else SymbolKind.FUNCTION
+                signature = _function_signature(node)
+            case _:
+                continue
+        qualname = f'{prefix}.{node.name}'
+        start = min([node.lineno, *(decorator.lineno for decorator in node.decorator_list)])
+        end = node.end_lineno or node.lineno
+        yield Symbol(
+            docstring=ast.get_docstring(node),
+            end_line=end,
+            kind=kind,
+            path=path,
+            project_id=project_id,
+            qualname=qualname,
+            ref=ref,
+            signature=signature,
+            source='\n'.join(lines[start - 1 : end]),
+            start_line=start,
+        )
+        yield from _walk(
+            body=node.body,
+            in_class=isinstance(node, ast.ClassDef),
+            lines=lines,
+            path=path,
+            prefix=qualname,
+            project_id=project_id,
+            ref=ref,
+        )
+
+
+def _class_signature(node: ast.ClassDef) -> str:
+    bases = ', '.join(ast.unparse(base) for base in [*node.bases, *node.keywords])
+    return f'class {node.name}({bases})' if bases else f'class {node.name}'
+
+
+def _function_signature(node: ast.FunctionDef | ast.AsyncFunctionDef) -> str:
+    keyword = 'async def' if isinstance(node, ast.AsyncFunctionDef) else 'def'
+    returns = f' -> {ast.unparse(node.returns)}' if node.returns else ''
+    return f'{keyword} {node.name}({ast.unparse(node.args)}){returns}'
+
+
+def _module_name(path: str) -> str:
+    parts = path.removesuffix('.py').split('/')
+    if parts[-1] == '__init__' and len(parts) > 1:
+        parts.pop()
+    return '.'.join(parts)