olink 0.1.0__py3-none-any.whl

olink/__init__.py

@@ -0,0 +1,5 @@
+"""olink - Open external URLs related to your project."""
+
+__version__ = "0.1.0"
+
+__all__ = ["__version__"]

olink/cli/__init__.py

@@ -0,0 +1,5 @@
+"""CLI interface for olink."""
+
+from olink.cli.app import app, main
+
+__all__ = ["app", "main"]

olink/cli/app.py

@@ -0,0 +1,132 @@
+"""CLI interface for olink."""
+
+import logging
+from pathlib import Path
+
+import typer
+
+from olink import __version__
+from olink.core.catalog import get_target, list_available_targets, list_targets
+from olink.core.exceptions import OlinkError
+
+logger = logging.getLogger(__name__)
+
+_TUI_OPTIONAL_DEPS = frozenset({"olink.tui", "textual", "pyperclip"})
+
+app = typer.Typer(
+    name="olink",
+    help="Open external URLs related to your project.",
+    no_args_is_help=False,
+)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"olink {__version__}")
+        raise typer.Exit(0)
+
+
+@app.callback(invoke_without_command=True)
+def main_callback(
+    target: str | None = typer.Argument(
+        None,
+        help="Target to open (e.g. origin, issues, pypi, npm, crates, and more — use --list-all to see all)",
+    ),
+    directory: str | None = typer.Option(
+        None,
+        "--directory",
+        "-d",
+        help="Project directory (defaults to current directory)",
+    ),
+    dry_run: bool = typer.Option(
+        False,
+        "--dry-run",
+        "-n",
+        help="Print URL without opening it",
+    ),
+    list_available_flag: bool = typer.Option(
+        False,
+        "--list",
+        "-l",
+        help="List targets available for current project",
+    ),
+    list_all_flag: bool = typer.Option(
+        False,
+        "--list-all",
+        "-a",
+        help="List all targets",
+    ),
+    _version: bool = typer.Option(
+        False,
+        "--version",
+        "-V",
+        help="Show olink version and exit",
+        callback=_version_callback,
+        is_eager=True,
+    ),
+) -> None:
+    """Open external URLs related to your project."""
+    cwd = directory or str(Path.cwd())
+
+    cwd_path = Path(cwd)
+    if not cwd_path.exists():
+        typer.echo(f"Error: Directory does not exist: {cwd}", err=True)
+        raise typer.Exit(1)
+    if not cwd_path.is_dir():
+        typer.echo(f"Error: Not a directory: {cwd}", err=True)
+        raise typer.Exit(1)
+
+    if list_available_flag:
+        available = list_available_targets(cwd)
+
+        if available:
+            typer.echo("Available targets for this project:\n")
+            for name, description, _, _ in available:
+                typer.echo(f"  {name:16} - {description}")
+            typer.echo(f"\n({len(available)} targets available)")
+        else:
+            typer.echo("No targets available for this project.")
+        raise typer.Exit(0)
+
+    if list_all_flag:
+        typer.echo("All targets:\n")
+        for name, description in list_targets():
+            typer.echo(f"  {name:16} - {description}")
+        raise typer.Exit(0)
+
+    if target is None:
+        try:
+            from olink.tui import launch_tui  # pylint: disable=import-outside-toplevel
+        except ImportError as e:
+            if e.name not in _TUI_OPTIONAL_DEPS:
+                raise
+            typer.echo(
+                "Error: TUI requires extra dependencies. Install with: "
+                "pip install olink[tui]  (or: uv tool install 'olink[tui]')",
+                err=True,
+            )
+            raise typer.Exit(1) from None
+
+        try:
+            launch_tui(cwd)
+        except KeyboardInterrupt, SystemExit:
+            pass
+        raise typer.Exit(0)
+
+    try:
+        target_instance = get_target(target)
+        url = target_instance.get_url(cwd)
+
+        if dry_run:
+            typer.echo(url)
+        else:
+            typer.echo(f"Opening: {url}")
+            typer.launch(url)
+    except OlinkError as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(1) from e
+
+
+def main() -> None:
+    """Entry point for the CLI."""
+    app()

olink/core/__init__.py

@@ -0,0 +1,31 @@
+"""Core functionality for olink."""
+
+from olink.core.catalog import REGISTRY, get_target, list_targets
+from olink.core.exceptions import (
+    NoRemoteError,
+    NotGitRepoError,
+    OlinkError,
+    ProjectMetadataError,
+    UnknownPlatformError,
+    UnknownTargetError,
+    UnsupportedFeatureError,
+)
+from olink.core.targets import GitPageTarget, MultiEcosystemTarget, Target
+
+__all__ = [
+    # Targets
+    "Target",
+    "GitPageTarget",
+    "MultiEcosystemTarget",
+    "REGISTRY",
+    "get_target",
+    "list_targets",
+    # Exceptions
+    "OlinkError",
+    "NotGitRepoError",
+    "NoRemoteError",
+    "UnknownPlatformError",
+    "UnknownTargetError",
+    "ProjectMetadataError",
+    "UnsupportedFeatureError",
+]

olink/core/catalog.py

@@ -0,0 +1,225 @@
+"""Target catalog - explicit registration of all targets."""
+
+import logging
+
+from olink.core.exceptions import (
+    NoRemoteError,
+    NotGitRepoError,
+    ProjectMetadataError,
+    UnknownTargetError,
+    UnsupportedFeatureError,
+)
+from olink.core.project import detect_ecosystems
+from olink.core.targets import (
+    ActionsTarget,
+    BranchesTarget,
+    BundlephobiaTarget,
+    ClickPyTarget,
+    # Service targets
+    CodecovTarget,
+    CommitsTarget,
+    CoverallsTarget,
+    CpanTarget,
+    # Rust
+    CratesTarget,
+    DepsDevTarget,
+    DiscussionsTarget,
+    DocsRsTarget,
+    EcosystemsTarget,
+    # Other ecosystems
+    GemsTarget,
+    GoDocsTarget,
+    # Go
+    GoPkgTarget,
+    HackageTarget,
+    HexTarget,
+    InspectorTarget,
+    IssuesTarget,
+    JsDelivrTarget,
+    LibrariesIOTarget,
+    LibRsTarget,
+    MavenTarget,
+    MultiEcosystemTarget,
+    NPMStatTarget,
+    # npm
+    NPMTarget,
+    NuGetTarget,
+    OpenVSXTarget,
+    # Git targets
+    OriginTarget,
+    PackagephobiaTarget,
+    PackagistTarget,
+    PePyTarget,
+    PipTrendsTarget,
+    PiWheelsTarget,
+    PubTarget,
+    PullsTarget,
+    PyPIJSONTarget,
+    PyPIStatsTarget,
+    # Python / PyPI
+    PyPITarget,
+    ReleasesTarget,
+    RubyGemsStatsTarget,
+    SafetyDBTarget,
+    SecurityTarget,
+    SkypackTarget,
+    # Multi-ecosystem
+    SnykTarget,
+    SocketTarget,
+    Target,
+    UnpkgTarget,
+    UpstreamTarget,
+    WikiTarget,
+)
+
+# Explicit registry of all available targets
+REGISTRY: dict[str, type[Target]] = {
+    # Git targets
+    "origin": OriginTarget,
+    "upstream": UpstreamTarget,
+    "issues": IssuesTarget,
+    "pulls": PullsTarget,
+    "actions": ActionsTarget,
+    "wiki": WikiTarget,
+    "releases": ReleasesTarget,
+    "branches": BranchesTarget,
+    "commits": CommitsTarget,
+    "security": SecurityTarget,
+    "discussions": DiscussionsTarget,
+    # Python / PyPI targets
+    "pypi": PyPITarget,
+    "inspector": InspectorTarget,
+    "pypi-json": PyPIJSONTarget,
+    "pepy": PePyTarget,
+    "piwheels": PiWheelsTarget,
+    "pypistats": PyPIStatsTarget,
+    "piptrends": PipTrendsTarget,
+    "clickpy": ClickPyTarget,
+    "snyk": SnykTarget,
+    "safety-db": SafetyDBTarget,
+    # Multi-ecosystem targets
+    "libraries-io": LibrariesIOTarget,
+    "deps": DepsDevTarget,
+    "ecosystems": EcosystemsTarget,
+    "socket": SocketTarget,
+    # npm targets
+    "npm": NPMTarget,
+    "bundlephobia": BundlephobiaTarget,
+    "packagephobia": PackagephobiaTarget,
+    "npm-stat": NPMStatTarget,
+    "jsdelivr": JsDelivrTarget,
+    "unpkg": UnpkgTarget,
+    "skypack": SkypackTarget,
+    # Rust targets
+    "crates": CratesTarget,
+    "librs": LibRsTarget,
+    "docsrs": DocsRsTarget,
+    # Go targets
+    "pkg-go": GoPkgTarget,
+    "go-docs": GoDocsTarget,
+    # Other ecosystem targets
+    "gems": GemsTarget,
+    "rubygems-stats": RubyGemsStatsTarget,
+    "packagist": PackagistTarget,
+    "pub": PubTarget,
+    "hex": HexTarget,
+    "nuget": NuGetTarget,
+    "open-vsx": OpenVSXTarget,
+    "maven": MavenTarget,
+    "hackage": HackageTarget,
+    "cpan": CpanTarget,
+    # Service targets
+    "codecov": CodecovTarget,
+    "coveralls": CoverallsTarget,
+}
+
+
+def get_target(name: str) -> Target:
+    """Get a target instance by name.
+
+    Supports suffix notation for multi-ecosystem targets:
+    - "snyk" - auto-detect ecosystem
+    - "snyk:pypi" - explicit Python ecosystem
+    - "deps:npm" - explicit npm ecosystem
+    """
+    if ":" in name:
+        base_name, ecosystem = name.split(":", 1)
+    else:
+        base_name, ecosystem = name, None
+
+    if base_name not in REGISTRY:
+        available = ", ".join(sorted(REGISTRY.keys()))
+        raise UnknownTargetError(f"Unknown target: '{base_name}'. Available targets: {available}")
+
+    target_cls = REGISTRY[base_name]
+
+    if ecosystem is not None:
+        if not issubclass(target_cls, MultiEcosystemTarget):
+            raise UnknownTargetError(
+                f"Target '{base_name}' doesn't support ecosystem suffix. "
+                f"Use '{base_name}' without suffix."
+            )
+        supported = sorted(target_cls.ecosystem_url_map.keys())
+        if ecosystem not in target_cls.ecosystem_url_map:
+            raise UnknownTargetError(
+                f"Target '{base_name}' doesn't support ecosystem '{ecosystem}'. "
+                f"Supported: {', '.join(supported)}"
+            )
+        return target_cls(ecosystem=ecosystem)
+
+    return target_cls()
+
+
+logger = logging.getLogger(__name__)
+
+# Exceptions that mean "this target doesn't apply here" — expected and safe to skip.
+UNAVAILABLE_ERRORS = (
+    NoRemoteError,
+    NotGitRepoError,
+    ProjectMetadataError,
+    UnsupportedFeatureError,
+)
+
+
+def list_targets() -> list[tuple[str, str]]:
+    """List all available targets with their descriptions."""
+    return [(name, target_cls.description) for name, target_cls in sorted(REGISTRY.items())]
+
+
+def list_available_targets(
+    cwd: str,
+) -> list[tuple[str, str, type[Target], str | None]]:
+    """List targets available for the current project.
+
+    Returns (name, description, target_cls, ecosystem) tuples.
+    """
+    results: list[tuple[str, str, type[Target], str | None]] = []
+    detected_ecosystems = detect_ecosystems(cwd)
+
+    for name, target_cls in sorted(REGISTRY.items()):
+        if issubclass(target_cls, MultiEcosystemTarget):
+            supported = [e for e in detected_ecosystems if e in target_cls.ecosystem_url_map]
+            if not supported:
+                continue
+            if len(supported) == 1:
+                try:
+                    target_cls(ecosystem=supported[0]).get_url(cwd)
+                    desc = f"{target_cls.description} ({supported[0]})"
+                    results.append((name, desc, target_cls, supported[0]))
+                except UNAVAILABLE_ERRORS as e:
+                    logger.debug("Skipping %s: %s", name, e)
+            else:
+                for eco in sorted(supported):
+                    try:
+                        target_cls(ecosystem=eco).get_url(cwd)
+                        results.append((f"{name}:{eco}", target_cls.description, target_cls, eco))
+                    except UNAVAILABLE_ERRORS as e:
+                        logger.debug("Skipping %s:%s: %s", name, eco, e)
+        else:
+            try:
+                target_cls().get_url(cwd)
+                results.append((name, target_cls.description, target_cls, None))
+            except UNAVAILABLE_ERRORS as e:
+                logger.debug("Skipping %s: %s", name, e)
+
+    return results

olink/core/exceptions.py

@@ -0,0 +1,29 @@
+"""Custom exceptions for olink."""
+
+
+class OlinkError(Exception):
+    """Base exception for olink."""
+
+
+class NotGitRepoError(OlinkError):
+    """Not inside a git repository."""
+
+
+class NoRemoteError(OlinkError):
+    """No git remote configured."""
+
+
+class UnknownPlatformError(OlinkError):
+    """Unknown git hosting platform."""
+
+
+class UnknownTargetError(OlinkError):
+    """Unknown target specified."""
+
+
+class ProjectMetadataError(OlinkError):
+    """Could not read project metadata."""
+
+
+class UnsupportedFeatureError(OlinkError):
+    """Feature not available on this platform."""