myopic 0.0.1__py3-none-any.whl

myopic/__init__.py

@@ -0,0 +1,9 @@
+"""
+myopic — the code-review MCP server with the most ironic name in the registry.
+
+It's anything but nearsighted. It reviews your merge request against the *whole*
+codebase — callers, conventions, duplication, dead code — not just the diff in
+front of it.
+"""
+
+__version__ = "0.0.1"

myopic/_wizard.py

@@ -0,0 +1,144 @@
+"""
+myopic setup wizard — interactive first-run configuration.
+
+Mirrors amnesic's wizard UX: prompt for the connection, verify it live, then
+persist it — the URL to config.toml (token referenced as ${GITLAB_TOKEN}) and
+the token value to a sibling .env at chmod 600, so secrets never sit in the TOML.
+
+Public API:
+  run_wizard(welcome)        — interactive flow (prompt → test → save)
+  test_connection(url, token)— returns (ok, username_or_error)
+  write_config_toml(url)     — write config.toml with ${GITLAB_TOKEN} reference
+  upsert_env_var(name, value)— insert/replace NAME=VALUE in .env, chmod 600
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import click
+
+from myopic.config import config_dir, config_path, env_path, invalidate_config_cache
+
+_CONFIG_TEMPLATE = """\
+# myopic config.toml
+# Documentation: https://github.com/SurajKGoyal/myopic
+#
+# The token is kept OUT of this file — it's referenced as ${{GITLAB_TOKEN}} and
+# its value lives in the sibling .env (chmod 600). Edit the URL here if your
+# GitLab instance moves; rotate the token with `myopic set-secret`.
+
+[gitlab]
+url = "{url}"
+token = "${{GITLAB_TOKEN}}"
+"""
+
+
+def _token_hint(url: str) -> str:
+    return f"{url.rstrip('/')}/-/user_settings/personal_access_tokens"
+
+
+def secure_file(path: Path) -> None:
+    """Best-effort chmod 600 — owner read/write only. No-op where unsupported."""
+    if os.name == "posix":
+        try:
+            os.chmod(path, 0o600)
+        except OSError:
+            pass
+
+
+def test_connection(url: str, token: str) -> tuple[bool, str]:
+    """Authenticate to GitLab. Returns (ok, username) or (False, error_message)."""
+    try:
+        import gitlab
+
+        client = gitlab.Gitlab(url=url, private_token=token)
+        client.auth()
+        user = client.user
+        return True, getattr(user, "username", "?") if user else "?"
+    except Exception as exc:
+        # Never surface the raw error — some python-gitlab versions echo the token.
+        first = str(exc).splitlines()[0][:120]
+        redacted = first.replace(token, "***") if token else first
+        return False, redacted
+
+
+def write_config_toml(url: str) -> None:
+    """Write config.toml with the URL and a ${GITLAB_TOKEN} reference."""
+    config_dir().mkdir(parents=True, exist_ok=True)
+    config_path().write_text(_CONFIG_TEMPLATE.format(url=url.rstrip("/")), encoding="utf-8")
+
+
+def upsert_env_var(name: str, value: str) -> None:
+    """Insert or replace NAME=VALUE in the .env, preserving other lines. chmod 600."""
+    config_dir().mkdir(parents=True, exist_ok=True)
+    path = env_path()
+
+    lines = path.read_text(encoding="utf-8").splitlines() if path.is_file() else []
+    out: list[str] = []
+    replaced = False
+    for line in lines:
+        stripped = line.strip()
+        if (
+            stripped and not stripped.startswith("#") and "=" in stripped
+            and stripped.split("=", 1)[0].strip() == name
+        ):
+            out.append(f"{name}={value}")
+            replaced = True
+        else:
+            out.append(line)
+    if not replaced:
+        out.append(f"{name}={value}")
+
+    content = "\n".join(out)
+    if content and not content.endswith("\n"):
+        content += "\n"
+    path.write_text(content, encoding="utf-8")
+    secure_file(path)
+
+
+def run_wizard(welcome: bool = True) -> None:
+    """Interactive GitLab setup: prompt → verify live → persist config + secret."""
+    config_dir().mkdir(parents=True, exist_ok=True)
+
+    if welcome:
+        click.echo()
+        click.echo("Welcome to myopic — the code-review MCP that sees the whole codebase.")
+        click.echo("Let's connect it to your GitLab.")
+        click.echo()
+
+    while True:
+        url = click.prompt("? GitLab URL", default="https://gitlab.com").rstrip("/")
+        click.echo()
+        click.echo("  Create a personal access token with 'api' (or 'read_api') scope:")
+        click.echo(f"    {_token_hint(url)}")
+        token = click.prompt("? Personal access token (hidden)", hide_input=True)
+
+        click.echo()
+        click.echo("  Testing connection...", nl=False)
+        ok, info = test_connection(url, token)
+
+        if ok:
+            click.echo(f" ✓ Authenticated as {info}.")
+            click.echo()
+            write_config_toml(url)
+            click.echo(f"  ✓ URL saved to {config_path()}")
+            upsert_env_var("GITLAB_TOKEN", token)
+            click.echo(f"  ✓ Token saved to {env_path()} (chmod 600)")
+            invalidate_config_cache()
+            break
+
+        click.echo(" ✗ Failed.")
+        click.echo(f"  Error: {info}")
+        click.echo()
+        if not click.confirm("? Try again with different details?", default=True):
+            raise SystemExit(1)
+        click.echo()
+
+    click.echo()
+    click.echo("Next steps:")
+    click.echo("  1. Run `myopic test` to re-verify the connection any time.")
+    click.echo("  2. Add myopic to your MCP client config (see the README snippet).")
+    click.echo("  3. Ask your AI client to review a merge request URL.")
+    click.echo()

myopic/ast_chunker.py

@@ -0,0 +1,264 @@
+"""
+AST-aware code chunking using tree-sitter.
+
+Splits code by semantic boundaries (functions, classes, methods) instead of
+fixed line windows. Falls back gracefully when tree-sitter grammars are
+unavailable or parsing fails.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+MAX_CHUNK_CHARS = 4_000
+
+# Mapping from our language names to tree-sitter module names + node types
+_LANGUAGE_CONFIG: dict[str, dict] = {
+    "python": {
+        "module": "tree_sitter_python",
+        "top_nodes": {
+            "function_definition", "class_definition", "decorated_definition",
+        },
+        "sub_nodes": {"function_definition"},  # methods inside classes
+    },
+    "javascript": {
+        "module": "tree_sitter_javascript",
+        "top_nodes": {
+            "function_declaration", "class_declaration", "export_statement",
+            "lexical_declaration", "expression_statement",
+        },
+        "sub_nodes": {"method_definition", "function_declaration"},
+    },
+    "typescript": {
+        "module": "tree_sitter_typescript",
+        "lang_attr": "language_typescript",
+        "top_nodes": {
+            "function_declaration", "class_declaration", "export_statement",
+            "lexical_declaration", "interface_declaration", "type_alias_declaration",
+            "expression_statement", "enum_declaration",
+        },
+        "sub_nodes": {"method_definition", "function_declaration"},
+    },
+    "java": {
+        "module": "tree_sitter_java",
+        "top_nodes": {
+            "class_declaration", "interface_declaration", "enum_declaration",
+            "method_declaration", "import_declaration",
+        },
+        "sub_nodes": {"method_declaration", "constructor_declaration"},
+    },
+    "go": {
+        "module": "tree_sitter_go",
+        "top_nodes": {
+            "function_declaration", "method_declaration", "type_declaration",
+        },
+        "sub_nodes": set(),
+    },
+    "rust": {
+        "module": "tree_sitter_rust",
+        "top_nodes": {
+            "function_item", "impl_item", "struct_item", "enum_item",
+            "trait_item", "mod_item",
+        },
+        "sub_nodes": {"function_item"},
+    },
+}
+
+# Cache parsed languages to avoid re-importing
+_parser_cache: dict[str, object] = {}
+
+
+def _get_parser(language: str):
+    """Get or create a tree-sitter parser for the given language."""
+    if language in _parser_cache:
+        return _parser_cache[language]
+
+    config = _LANGUAGE_CONFIG.get(language)
+    if not config:
+        return None
+
+    try:
+        import importlib
+
+        import tree_sitter
+
+        mod = importlib.import_module(config["module"])
+        lang_attr = config.get("lang_attr", "language")
+        lang_fn = getattr(mod, lang_attr, None)
+        if lang_fn is None:
+            # some grammars export language() as a function
+            lang_fn = getattr(mod, "language", None)
+        if lang_fn is None:
+            return None
+
+        raw_lang = lang_fn()
+        # tree-sitter >=0.24 returns PyCapsule from language(), wrap it
+        if not isinstance(raw_lang, tree_sitter.Language):
+            lang_obj = tree_sitter.Language(raw_lang)
+        else:
+            lang_obj = raw_lang
+        parser = tree_sitter.Parser(lang_obj)
+        _parser_cache[language] = (parser, config)
+        return (parser, config)
+    except (ImportError, AttributeError, Exception) as e:
+        logger.debug("tree-sitter unavailable for %s: %s", language, e)
+        _parser_cache[language] = None
+        return None
+
+
+def _extract_symbol_name(node) -> Optional[str]:
+    """Extract the name of a function/class/method from an AST node."""
+    # Look for a 'name' or 'identifier' child
+    for child in node.children:
+        if child.type in ("identifier", "name", "property_identifier", "type_identifier"):
+            return child.text.decode("utf-8", errors="replace")
+    # For decorated_definition / export_statement, recurse into the actual definition
+    for child in node.children:
+        if "definition" in child.type or "declaration" in child.type:
+            return _extract_symbol_name(child)
+    return None
+
+
+def _node_symbol_type(node) -> str:
+    """Classify a node as 'class', 'function', 'method', 'interface', or 'other'."""
+    t = node.type
+    if "class" in t:
+        return "class"
+    if "interface" in t:
+        return "interface"
+    if "method" in t or "constructor" in t:
+        return "method"
+    if "function" in t:
+        return "function"
+    if "enum" in t:
+        return "enum"
+    if "impl" in t or "trait" in t:
+        return "trait"
+    return "other"
+
+
+def ast_chunk(
+    content: str,
+    language: str,
+) -> Optional[list[tuple[str, int, int, Optional[str], str]]]:
+    """
+    Split content by AST boundaries.
+
+    Returns list of (chunk_text, start_line_1indexed, end_line_1indexed, symbol_name, symbol_type)
+    or None if tree-sitter is unavailable / parsing fails.
+    """
+    result = _get_parser(language)
+    if result is None:
+        return None
+
+    parser, config = result
+    top_nodes = config["top_nodes"]
+    sub_nodes = config.get("sub_nodes", set())
+
+    try:
+        tree = parser.parse(content.encode("utf-8"))
+    except Exception as e:
+        logger.debug("tree-sitter parse failed for %s: %s", language, e)
+        return None
+
+    lines = content.split("\n")
+    chunks: list[tuple[str, int, int, Optional[str], str]] = []
+
+    def _extract_node(node, is_sub: bool = False):
+        """Extract a node as a chunk, potentially splitting large nodes."""
+        start_line = node.start_point[0]  # 0-indexed
+        end_line = node.end_point[0]  # 0-indexed
+        text = "\n".join(lines[start_line:end_line + 1])
+        name = _extract_symbol_name(node)
+        sym_type = _node_symbol_type(node)
+
+        if len(text) <= MAX_CHUNK_CHARS:
+            chunks.append((text, start_line + 1, end_line + 1, name, sym_type))
+            return
+
+        # Large node — try to split by sub-nodes (e.g., methods in a class)
+        if not is_sub and sub_nodes:
+            sub_children = [c for c in node.children if c.type in sub_nodes]
+            if sub_children:
+                # Add class header (everything before first method)
+                first_sub_start = sub_children[0].start_point[0]
+                if first_sub_start > start_line:
+                    header = "\n".join(lines[start_line:first_sub_start])
+                    if header.strip() and len(header) <= MAX_CHUNK_CHARS:
+                        chunks.append((header, start_line + 1, first_sub_start, name, sym_type))
+
+                for sub in sub_children:
+                    _extract_node(sub, is_sub=True)
+                return
+
+        # Fallback: split oversized node into MAX_CHUNK_CHARS pieces
+        chunk_lines = []
+        chunk_start = start_line
+        current_len = 0
+        for i in range(start_line, end_line + 1):
+            line = lines[i] if i < len(lines) else ""
+            if current_len + len(line) + 1 > MAX_CHUNK_CHARS and chunk_lines:
+                chunks.append((
+                    "\n".join(chunk_lines),
+                    chunk_start + 1,
+                    chunk_start + len(chunk_lines),
+                    name,
+                    sym_type,
+                ))
+                chunk_lines = []
+                chunk_start = i
+                current_len = 0
+            chunk_lines.append(line)
+            current_len += len(line) + 1
+
+        if chunk_lines:
+            chunks.append((
+                "\n".join(chunk_lines),
+                chunk_start + 1,
+                chunk_start + len(chunk_lines),
+                name,
+                sym_type,
+            ))
+
+    # Collect top-level nodes
+    root = tree.root_node
+    collected_ranges: list[tuple[int, int]] = []
+
+    for child in root.children:
+        if child.type in top_nodes:
+            _extract_node(child)
+            collected_ranges.append((child.start_point[0], child.end_point[0]))
+
+    # Merge uncollected lines (imports, module-level code) into a preamble chunk
+    if collected_ranges and lines:
+        collected_ranges.sort()
+        uncollected_lines = []
+        uncollected_start = 0
+
+        for rng_start, rng_end in collected_ranges:
+            for i in range(uncollected_start, rng_start):
+                if i < len(lines) and lines[i].strip():
+                    uncollected_lines.append((i, lines[i]))
+            uncollected_start = rng_end + 1
+
+        # Trailing lines after last collected node
+        for i in range(uncollected_start, len(lines)):
+            if lines[i].strip():
+                uncollected_lines.append((i, lines[i]))
+
+        if uncollected_lines:
+            preamble_text = "\n".join(l[1] for l in uncollected_lines)
+            if len(preamble_text) <= MAX_CHUNK_CHARS and preamble_text.strip():
+                first_line = uncollected_lines[0][0] + 1
+                last_line = uncollected_lines[-1][0] + 1
+                chunks.append((preamble_text, first_line, last_line, None, "preamble"))
+
+    if not chunks:
+        return None
+
+    # Sort by start line
+    chunks.sort(key=lambda c: c[1])
+    return chunks

myopic/cli.py

@@ -0,0 +1,148 @@
+"""
+myopic CLI
+
+Commands:
+  myopic init               — interactive setup wizard (prompt → test → save)
+  myopic init --template    — write a blank config template for hand-editing
+  myopic set-secret         — set or rotate the GitLab token (hidden input)
+  myopic test               — verify the configured GitLab connection
+  (no subcommand)           — start the MCP server when launched by a client
+"""
+
+from __future__ import annotations
+
+import click
+from rich.console import Console
+
+from myopic.config import config_dir, config_path
+
+console = Console()
+
+_TOKEN_HINT = "https://gitlab.com/-/user_settings/personal_access_tokens"
+
+_TEMPLATE = """\
+# myopic config.toml
+# Documentation: https://github.com/SurajKGoyal/myopic
+#
+# myopic needs a GitLab URL and a personal access token with `api` (or at least
+# `read_api`) scope. Keep the token OUT of this file — reference it via ${VAR}
+# and put the value in a sibling .env file (config dir / .env), or export it in
+# your environment.
+
+[gitlab]
+url = "https://gitlab.com"
+token = "${GITLAB_TOKEN}"
+"""
+
+
+@click.group(invoke_without_command=True)
+@click.pass_context
+def cli(ctx: click.Context) -> None:
+    """myopic — the code-review MCP that sees the whole codebase, not just the diff.
+
+    With no subcommand:
+      • If stdin is piped (an MCP client launched us) → start the MCP server.
+      • If stdin is a TTY (you ran 'myopic' in your terminal) → show this help.
+    """
+    if ctx.invoked_subcommand is not None:
+        return
+
+    import sys
+
+    if sys.stdin.isatty():
+        click.echo(ctx.get_help())
+        return
+
+    from myopic.server import main as _server_main
+
+    _server_main()
+
+
+@cli.command()
+@click.option("--template", is_flag=True, default=False,
+              help="Write a blank config template for hand-editing instead of running the wizard.")
+def init(template: bool) -> None:
+    """Set up myopic interactively (wizard). Pass --template to hand-edit instead.
+
+    The wizard prompts for your GitLab URL and token, verifies the connection
+    live, then saves the URL to config.toml and the token to a sibling .env
+    (chmod 600) so the secret never lives in the TOML.
+    """
+    cfg_dir = config_dir()
+    cfg_file = config_path()
+
+    if template:
+        if cfg_file.exists():
+            console.print(
+                f"[yellow]Config already exists:[/yellow] {cfg_file}\n"
+                f"Edit it directly, or delete it and re-run."
+            )
+            raise SystemExit(0)
+        cfg_dir.mkdir(parents=True, exist_ok=True)
+        cfg_file.write_text(_TEMPLATE, encoding="utf-8")
+        console.print(f"[green]Created:[/green] {cfg_file}")
+        console.print()
+        console.print("[bold]Next steps:[/bold]")
+        console.print(f"  1. Create a GitLab token (api scope): [cyan]{_TOKEN_HINT}[/cyan]")
+        console.print(f"  2. Put it in [cyan]{cfg_dir / '.env'}[/cyan] as [cyan]GITLAB_TOKEN=...[/cyan]")
+        console.print(f"  3. Edit [cyan]{cfg_file}[/cyan] if your GitLab URL is self-hosted")
+        console.print(f"  4. Run [cyan]myopic test[/cyan] to verify the connection")
+        return
+
+    if cfg_file.exists():
+        if not click.confirm(
+            f"Config already exists at {cfg_file}. Reconfigure?", default=False
+        ):
+            console.print(
+                "Left unchanged. Use [cyan]myopic set-secret[/cyan] to rotate just the token."
+            )
+            raise SystemExit(0)
+
+    from myopic._wizard import run_wizard
+    run_wizard(welcome=True)
+
+
+@cli.command("set-secret")
+def set_secret() -> None:
+    """Set or rotate the GitLab token in ~/.config/myopic/.env (hidden input)."""
+    value = click.prompt("GitLab token", hide_input=True, confirmation_prompt=True)
+
+    from myopic._wizard import upsert_env_var
+    from myopic.config import invalidate_config_cache
+
+    upsert_env_var("GITLAB_TOKEN", value)
+    invalidate_config_cache()
+    console.print(
+        f"[green]✓[/green] Saved GITLAB_TOKEN to {config_dir() / '.env'} (chmod 600)"
+    )
+
+
+@cli.command()
+def test() -> None:
+    """Verify that the configured GitLab URL + token authenticate successfully."""
+    from myopic.config import load_config
+
+    try:
+        cfg = load_config()
+    except ValueError as exc:
+        console.print(f"[red]Config error:[/red] {exc}")
+        raise SystemExit(1) from exc
+
+    try:
+        import gitlab
+
+        client = gitlab.Gitlab(url=cfg.url, private_token=cfg.token)
+        client.auth()
+        user = client.user
+        username = getattr(user, "username", "?") if user else "?"
+        console.print(
+            f"[green]✓[/green] Authenticated to [cyan]{cfg.url}[/cyan] as [bold]{username}[/bold]"
+        )
+    except Exception as exc:
+        msg = str(exc).splitlines()[0][:120]
+        console.print(f"[red]✗[/red] Could not authenticate to {cfg.url}: [red]{msg}[/red]")
+        raise SystemExit(1) from exc
+
+
+if __name__ == "__main__":
+    cli()