entrygraph 0.1.0__py3-none-any.whl

entrygraph/detect/entrypoints/python.py

@@ -0,0 +1,335 @@
+"""Python entrypoint rules: flask, fastapi, django urls, click/typer, celery,
+lambda handlers, and the language-core __main__ guard."""
+
+from __future__ import annotations
+
+import re
+
+from entrygraph.detect.entrypoints.base import (
+    EntrypointRule,
+    first_string_arg,
+    identifier_args,
+    methods_kwarg,
+    register,
+    tainted_params,
+)
+from entrygraph.extract.ir import EntrypointHint, FileExtraction, RawSymbol
+from entrygraph.kinds import EntrypointKind, SymbolKind
+
+_FLASK_ROUTE = re.compile(r"^@(\w+)\.route\(")
+_HTTP_VERB = re.compile(r"^@(\w+)\.(get|post|put|delete|patch|head|options)\(")
+_CLICK_CMD = re.compile(r"^@(?:click\.(command|group)|(\w+)\.(command|group))\b")
+_CELERY_TASK = re.compile(r"^@(?:shared_task\b|task\b|(\w+)\.task\b)")
+_MIDDLEWARE_DECORATOR = re.compile(
+    r"^@(\w+)\.(before_request|after_request|before_first_request|errorhandler|middleware|teardown_request)\b"
+)
+_DJANGO_PATH_CALL = frozenset({"path", "re_path", "url"})
+_LAMBDA_NAMES = frozenset({"lambda_handler", "handler"})
+
+
+def _decorated(x: FileExtraction) -> list[tuple[RawSymbol, str]]:
+    return [(s, d) for s in x.symbols for d in s.decorators
+            if s.kind in (SymbolKind.FUNCTION, SymbolKind.METHOD)]
+
+
+def _taint_meta(symbol: RawSymbol, kind: str) -> dict:
+    params = tainted_params(symbol.signature, kind)
+    return {"tainted_params": params} if params else {}
+
+
+def _flask_routes(x: FileExtraction) -> list[EntrypointHint]:
+    hints = []
+    for symbol, decorator in _decorated(x):
+        route = None
+        methods: list[str] = []
+        if _FLASK_ROUTE.match(decorator):
+            route = first_string_arg(decorator)
+            methods = methods_kwarg(decorator) or ["GET"]
+        else:
+            verb = _HTTP_VERB.match(decorator)
+            if verb:
+                route = first_string_arg(decorator)
+                methods = [verb.group(2).upper()]
+        if route is not None:
+            hints.append(
+                EntrypointHint(
+                    rule_id="python.flask.route",
+                    kind=EntrypointKind.HTTP_ROUTE,
+                    handler_qualified_name=symbol.qualified_name,
+                    route=route,
+                    http_methods=methods,
+                    framework="flask",
+                    metadata=_taint_meta(symbol, "http_route"),
+                )
+            )
+    return hints
+
+
+def _flask_add_url_rule(x: FileExtraction) -> list[EntrypointHint]:
+    """Call-based route registration: app.add_url_rule("/x", view_func=handler)."""
+    hints = []
+    for ref in x.references:
+        if ref.kind != "call" or ref.callee_name != "add_url_rule" or not ref.arg_preview:
+            continue
+        route = first_string_arg("(" + ref.arg_preview.lstrip("("))
+        handler = None
+        for name in identifier_args(ref.arg_preview):
+            candidate = f"{x.module_path}.{name}"
+            if any(s.qualified_name == candidate for s in x.symbols):
+                handler = candidate
+                break
+        hints.append(
+            EntrypointHint(
+                rule_id="python.flask.add_url_rule",
+                kind=EntrypointKind.HTTP_ROUTE,
+                handler_qualified_name=handler,
+                route=route if route is not None else "",
+                http_methods=["*"],
+                framework="flask",
+                metadata={"registration": ref.arg_preview},
+            )
+        )
+    return hints
+
+
+def _middleware(x: FileExtraction) -> list[EntrypointHint]:
+    """before_request / after_request / errorhandler / app.middleware wrappers."""
+    hints = []
+    for symbol, decorator in _decorated(x):
+        m = _MIDDLEWARE_DECORATOR.match(decorator)
+        if m:
+            framework = "fastapi" if m.group(2) == "middleware" else "flask"
+            hints.append(
+                EntrypointHint(
+                    rule_id="python.web.middleware",
+                    kind=EntrypointKind.MIDDLEWARE,
+                    handler_qualified_name=symbol.qualified_name,
+                    name=m.group(2),
+                    framework=framework,
+                )
+            )
+    return hints
+
+
+def _fastapi_routes(x: FileExtraction) -> list[EntrypointHint]:
+    hints = []
+    for symbol, decorator in _decorated(x):
+        verb = _HTTP_VERB.match(decorator)
+        if verb:
+            route = first_string_arg(decorator)
+            if route is not None:
+                hints.append(
+                    EntrypointHint(
+                        rule_id="python.fastapi.route",
+                        kind=EntrypointKind.HTTP_ROUTE,
+                        handler_qualified_name=symbol.qualified_name,
+                        route=route,
+                        http_methods=[verb.group(2).upper()],
+                        framework="fastapi",
+                        metadata=_taint_meta(symbol, "http_route"),
+                    )
+                )
+    return hints
+
+
+def _django_urls(x: FileExtraction) -> list[EntrypointHint]:
+    if not x.path.endswith("urls.py"):
+        return []
+    hints = []
+    for ref in x.references:
+        if ref.kind == "call" and ref.callee_name in _DJANGO_PATH_CALL and ref.arg_preview:
+            route = first_string_arg("(" + ref.arg_preview.lstrip("("))
+            hints.append(
+                EntrypointHint(
+                    rule_id="python.django.urls",
+                    kind=EntrypointKind.HTTP_ROUTE,
+                    handler_qualified_name=None,  # handler resolved as a normal call edge
+                    route=route if route is not None else "",
+                    http_methods=["*"],
+                    framework="django",
+                    metadata={"registration": ref.arg_preview},
+                )
+            )
+    return hints
+
+
+def _click_commands(x: FileExtraction) -> list[EntrypointHint]:
+    hints = []
+    for symbol, decorator in _decorated(x):
+        if _CLICK_CMD.match(decorator):
+            hints.append(
+                EntrypointHint(
+                    rule_id="python.click.command",
+                    kind=EntrypointKind.CLI_COMMAND,
+                    handler_qualified_name=symbol.qualified_name,
+                    name=first_string_arg(decorator) or symbol.name,
+                    framework="click",
+                )
+            )
+    return hints
+
+
+def _celery_tasks(x: FileExtraction) -> list[EntrypointHint]:
+    hints = []
+    for symbol, decorator in _decorated(x):
+        if _CELERY_TASK.match(decorator):
+            hints.append(
+                EntrypointHint(
+                    rule_id="python.celery.task",
+                    kind=EntrypointKind.TASK,
+                    handler_qualified_name=symbol.qualified_name,
+                    name=symbol.name,
+                    framework="celery",
+                )
+            )
+    return hints
+
+
+def _lambda_handlers(x: FileExtraction) -> list[EntrypointHint]:
+    hints = []
+    for symbol in x.symbols:
+        if (
+            symbol.kind is SymbolKind.FUNCTION
+            and symbol.name in _LAMBDA_NAMES
+            and symbol.signature
+            and "event" in symbol.signature
+            and "context" in symbol.signature
+        ):
+            hints.append(
+                EntrypointHint(
+                    rule_id="python.lambda.handler",
+                    kind=EntrypointKind.LAMBDA_HANDLER,
+                    handler_qualified_name=symbol.qualified_name,
+                    name=symbol.name,
+                    framework="aws-lambda",
+                    metadata=_taint_meta(symbol, "lambda_handler"),
+                )
+            )
+    return hints
+
+
+_VIEW_CONFIG = re.compile(r"^@view_config\b")
+_DRAMATIQ_ACTOR = re.compile(r"^@(?:dramatiq\.actor|actor)\b")
+_AIRFLOW_TASK = re.compile(r"^@(?:task|dag)\b")
+_AIOHTTP_ADD = frozenset({"add_get", "add_post", "add_put", "add_delete", "add_route"})
+
+
+def _sanic_bottle_routes(framework: str):
+    """@app.route / @app.get style routes, framework-labelled (sanic, bottle)."""
+
+    def matcher(x: FileExtraction) -> list[EntrypointHint]:
+        hints = []
+        for symbol, decorator in _decorated(x):
+            route = methods = None
+            if _FLASK_ROUTE.match(decorator):
+                route, methods = first_string_arg(decorator), methods_kwarg(decorator) or ["GET"]
+            else:
+                verb = _HTTP_VERB.match(decorator)
+                if verb:
+                    route, methods = first_string_arg(decorator), [verb.group(2).upper()]
+            if route is not None:
+                hints.append(EntrypointHint(
+                    rule_id=f"python.{framework}.route", kind=EntrypointKind.HTTP_ROUTE,
+                    handler_qualified_name=symbol.qualified_name, route=route,
+                    http_methods=methods, framework=framework,
+                    metadata=_taint_meta(symbol, "http_route")))
+        return hints
+
+    return matcher
+
+
+def _decorator_rule(pattern, rule_id, kind, framework):
+    """Simple decorator-matched entrypoint (pyramid view, dramatiq actor, airflow task)."""
+
+    def matcher(x: FileExtraction) -> list[EntrypointHint]:
+        hints = []
+        for symbol, decorator in _decorated(x):
+            if pattern.match(decorator):
+                hints.append(EntrypointHint(
+                    rule_id=rule_id, kind=kind,
+                    handler_qualified_name=symbol.qualified_name,
+                    name=symbol.name, framework=framework,
+                    route=first_string_arg(decorator) if kind is EntrypointKind.HTTP_ROUTE else None,
+                    metadata=_taint_meta(symbol, kind.value)))
+        return hints
+
+    return matcher
+
+
+def _aiohttp_routes(x: FileExtraction) -> list[EntrypointHint]:
+    """router.add_get('/x', handler) / @routes.get('/x') registrations."""
+    hints = []
+    for ref in x.references:
+        if ref.kind == "call" and ref.callee_name in _AIOHTTP_ADD and ref.arg_preview:
+            route = first_string_arg("(" + ref.arg_preview.lstrip("("))
+            hints.append(EntrypointHint(
+                rule_id="python.aiohttp.route", kind=EntrypointKind.HTTP_ROUTE,
+                handler_qualified_name=None, route=route or "",
+                http_methods=[ref.callee_name.replace("add_", "").upper()], framework="aiohttp",
+                metadata={"registration": ref.arg_preview}))
+    for symbol, decorator in _decorated(x):
+        verb = _HTTP_VERB.match(decorator.replace("@routes.", "@r."))
+        if decorator.startswith("@routes.") and verb:
+            route = first_string_arg(decorator)
+            if route is not None:
+                hints.append(EntrypointHint(
+                    rule_id="python.aiohttp.route", kind=EntrypointKind.HTTP_ROUTE,
+                    handler_qualified_name=symbol.qualified_name, route=route,
+                    http_methods=[verb.group(2).upper()], framework="aiohttp",
+                    metadata=_taint_meta(symbol, "http_route")))
+    return hints
+
+
+def _main_guard(x: FileExtraction) -> list[EntrypointHint]:
+    if ("main_guard", x.module_path) not in x.framework_signals:
+        return []
+    return [
+        EntrypointHint(
+            rule_id="python.core.main",
+            kind=EntrypointKind.MAIN,
+            handler_qualified_name=None,  # the module itself
+            name=x.module_path,
+        )
+    ]
+
+
+register(EntrypointRule("python.flask.route", "python", "flask",
+                        EntrypointKind.HTTP_ROUTE, _flask_routes))
+register(EntrypointRule("python.flask.add_url_rule", "python", "flask",
+                        EntrypointKind.HTTP_ROUTE, _flask_add_url_rule))
+register(EntrypointRule("python.flask.middleware", "python", "flask",
+                        EntrypointKind.MIDDLEWARE, _middleware))
+register(EntrypointRule("python.fastapi.middleware", "python", "fastapi",
+                        EntrypointKind.MIDDLEWARE, _middleware))
+register(EntrypointRule("python.fastapi.route", "python", "fastapi",
+                        EntrypointKind.HTTP_ROUTE, _fastapi_routes))
+register(EntrypointRule("python.django.urls", "python", "django",
+                        EntrypointKind.HTTP_ROUTE, _django_urls))
+register(EntrypointRule("python.click.command", "python", "click",
+                        EntrypointKind.CLI_COMMAND, _click_commands))
+register(EntrypointRule("python.typer.command", "python", "typer",
+                        EntrypointKind.CLI_COMMAND, _click_commands))
+register(EntrypointRule("python.celery.task", "python", "celery",
+                        EntrypointKind.TASK, _celery_tasks))
+register(EntrypointRule("python.lambda.handler", "python", "aws-lambda",
+                        EntrypointKind.LAMBDA_HANDLER, _lambda_handlers))
+register(EntrypointRule("python.sanic.route", "python", "sanic",
+                        EntrypointKind.HTTP_ROUTE, _sanic_bottle_routes("sanic")))
+register(EntrypointRule("python.bottle.route", "python", "bottle",
+                        EntrypointKind.HTTP_ROUTE, _sanic_bottle_routes("bottle")))
+register(EntrypointRule("python.aiohttp.route", "python", "aiohttp",
+                        EntrypointKind.HTTP_ROUTE, _aiohttp_routes))
+register(EntrypointRule("python.pyramid.view", "python", "pyramid",
+                        EntrypointKind.HTTP_ROUTE,
+                        _decorator_rule(_VIEW_CONFIG, "python.pyramid.view",
+                                        EntrypointKind.HTTP_ROUTE, "pyramid")))
+register(EntrypointRule("python.dramatiq.actor", "python", "dramatiq",
+                        EntrypointKind.TASK,
+                        _decorator_rule(_DRAMATIQ_ACTOR, "python.dramatiq.actor",
+                                        EntrypointKind.TASK, "dramatiq")))
+register(EntrypointRule("python.airflow.task", "python", "airflow",
+                        EntrypointKind.TASK,
+                        _decorator_rule(_AIRFLOW_TASK, "python.airflow.task",
+                                        EntrypointKind.TASK, "airflow")))
+register(EntrypointRule("python.core.main", "python", None,
+                        EntrypointKind.MAIN, _main_guard))

entrygraph/detect/entrypoints/ruby.py

@@ -0,0 +1,147 @@
+"""Ruby entrypoint rules: Sinatra routes, Rails route DSL, and Rake tasks.
+
+Ruby route DSLs are bare top-level method calls (``get '/x' do ... end``), not
+decorators, so these rules match against extracted call references rather than
+symbol decorators. Sinatra handlers are inline blocks with no named symbol, so
+the handler qualified name is the enclosing method (usually None at file top
+level) — the block body's calls still resolve as ordinary edges.
+"""
+
+from __future__ import annotations
+
+from entrygraph.detect.entrypoints.base import (
+    EntrypointRule,
+    first_string_arg,
+    register,
+)
+from entrygraph.extract.ir import EntrypointHint, FileExtraction
+from entrygraph.kinds import EntrypointKind
+
+_SINATRA_VERBS = frozenset({"get", "post", "put", "delete", "patch"})
+_RAILS_VERBS = frozenset({"get", "post", "put", "patch", "delete", "resources", "resource", "root"})
+
+
+def _sinatra_routes(x: FileExtraction) -> list[EntrypointHint]:
+    hints = []
+    for ref in x.references:
+        if (
+            ref.kind == "call"
+            and ref.receiver_text is None
+            and ref.callee_name in _SINATRA_VERBS
+            and ref.arg_preview
+        ):
+            route = first_string_arg("(" + ref.arg_preview.lstrip("("))
+            if route is not None and route.startswith("/"):
+                hints.append(
+                    EntrypointHint(
+                        rule_id="ruby.sinatra.route",
+                        kind=EntrypointKind.HTTP_ROUTE,
+                        handler_qualified_name=ref.caller_qualified_name,
+                        route=route,
+                        http_methods=[ref.callee_name.upper()],
+                        framework="sinatra",
+                    )
+                )
+    return hints
+
+
+def _rails_routes(x: FileExtraction) -> list[EntrypointHint]:
+    if not x.path.endswith("config/routes.rb"):
+        return []
+    hints = []
+    for ref in x.references:
+        if ref.kind != "call" or ref.receiver_text is not None:
+            continue
+        if ref.callee_name not in _RAILS_VERBS:
+            continue
+        route = None
+        if ref.arg_preview:
+            route = first_string_arg("(" + ref.arg_preview.lstrip("("))
+        hints.append(
+            EntrypointHint(
+                rule_id="ruby.rails.routes",
+                kind=EntrypointKind.HTTP_ROUTE,
+                handler_qualified_name=None,  # handler resolved as a normal call edge
+                route=route if route is not None else "",
+                http_methods=["*"] if ref.callee_name in ("resources", "resource", "root")
+                else [ref.callee_name.upper()],
+                framework="rails",
+                metadata={"registration": ref.arg_preview or ref.callee_name},
+            )
+        )
+    return hints
+
+
+def _rake_tasks(x: FileExtraction) -> list[EntrypointHint]:
+    hints = []
+    for ref in x.references:
+        if ref.kind == "call" and ref.receiver_text is None and ref.callee_name == "task":
+            name = None
+            if ref.arg_preview:
+                name = first_string_arg("(" + ref.arg_preview.lstrip("("))
+                if name is None:
+                    # symbol arg like `:build` — strip the leading colon
+                    stripped = ref.arg_preview.strip("()").lstrip(":").split(" ", 1)[0]
+                    stripped = stripped.split("=", 1)[0].strip().rstrip(",")
+                    name = stripped or None
+            hints.append(
+                EntrypointHint(
+                    rule_id="ruby.rake.task",
+                    kind=EntrypointKind.CLI_COMMAND,
+                    handler_qualified_name=ref.caller_qualified_name,
+                    name=name or "task",
+                    framework="rake",
+                )
+            )
+    return hints
+
+
+def _grape_routes(x: FileExtraction) -> list[EntrypointHint]:
+    """Grape API classes: class-body `get '/x'` / `post '/y'` declarations."""
+    hints = []
+    for ref in x.references:
+        if (
+            ref.kind == "call"
+            and ref.receiver_text is None
+            and ref.callee_name in _SINATRA_VERBS
+            and ref.arg_preview
+        ):
+            route = first_string_arg("(" + ref.arg_preview.lstrip("("))
+            if route is not None:
+                hints.append(EntrypointHint(
+                    rule_id="ruby.grape.route", kind=EntrypointKind.HTTP_ROUTE,
+                    handler_qualified_name=ref.caller_qualified_name,
+                    route=route, http_methods=[ref.callee_name.upper()], framework="grape"))
+    return hints
+
+
+def _sidekiq_workers(x: FileExtraction) -> list[EntrypointHint]:
+    """Classes including Sidekiq::Worker/Job expose `perform` as a task handler."""
+    worker_modules = {
+        ref.caller_qualified_name
+        for ref in x.references
+        if ref.callee_name == "include" and ref.arg_preview
+        and "Sidekiq" in ref.arg_preview
+    }
+    hints = []
+    for symbol in x.symbols:
+        if symbol.name == "perform" and (
+            symbol.parent_qualified_name in worker_modules or not worker_modules
+        ) and worker_modules:
+            hints.append(EntrypointHint(
+                rule_id="ruby.sidekiq.worker", kind=EntrypointKind.TASK,
+                handler_qualified_name=symbol.qualified_name,
+                name=symbol.parent_qualified_name or symbol.name, framework="sidekiq"))
+    return hints
+
+
+register(EntrypointRule("ruby.sinatra.route", "ruby", "sinatra",
+                        EntrypointKind.HTTP_ROUTE, _sinatra_routes))
+register(EntrypointRule("ruby.grape.route", "ruby", "grape",
+                        EntrypointKind.HTTP_ROUTE, _grape_routes))
+register(EntrypointRule("ruby.sidekiq.worker", "ruby", "sidekiq",
+                        EntrypointKind.TASK, _sidekiq_workers))
+register(EntrypointRule("ruby.rails.routes", "ruby", "rails",
+                        EntrypointKind.HTTP_ROUTE, _rails_routes))
+register(EntrypointRule("ruby.rake.task", "ruby", "rake",
+                        EntrypointKind.CLI_COMMAND, _rake_tasks))

entrygraph/detect/entrypoints/rust.py

@@ -0,0 +1,153 @@
+"""Rust entrypoint rules: the crate ``main`` (and ``#[tokio::main]`` /
+``#[actix_web::main]`` async mains), axum router routes, actix-web/rocket route
+attribute macros, and clap ``#[derive(Parser)]`` CLI commands.
+
+Rules are IR-driven: axum routes read ``route(...)`` call references (the same
+low-fidelity tradeoff as the Express rule — the handler lives inside the second
+argument, so ``handler_qualified_name`` is left None and the raw registration is
+stashed in ``metadata``). actix/rocket/clap rules read attribute macros captured
+on ``RawSymbol.decorators`` as raw source text (``#[get("/x")]``).
+"""
+
+from __future__ import annotations
+
+import re
+
+from entrygraph.detect.entrypoints.base import (
+    EntrypointRule,
+    first_string_arg,
+    register,
+)
+from entrygraph.extract.ir import EntrypointHint, FileExtraction, RawSymbol
+from entrygraph.kinds import EntrypointKind, SymbolKind
+
+# #[get("/x")] / #[post(..)] / ... on a handler function -> HTTP verb.
+_ROUTE_ATTR = re.compile(r"^#\[\s*(get|post|put|delete|patch|head|route)\s*\(")
+_VERB = {
+    "get": "GET", "post": "POST", "put": "PUT", "delete": "DELETE",
+    "patch": "PATCH", "head": "HEAD",
+}
+# #[derive(.. Parser ..)] anywhere in the derive list.
+_DERIVE_PARSER = re.compile(r"^#\[\s*derive\s*\(.*\bParser\b")
+# #[tokio::main] / #[actix_web::main] async entrypoints.
+_ASYNC_MAIN = re.compile(r"^#\[\s*(?:tokio|actix_web|async_std)::main\b")
+
+
+def _rust_main(x: FileExtraction) -> list[EntrypointHint]:
+    hints = []
+    for symbol in x.symbols:
+        if symbol.kind is not SymbolKind.FUNCTION:
+            continue
+        is_crate_main = symbol.name == "main" and symbol.parent_qualified_name is None
+        is_async_main = any(_ASYNC_MAIN.match(d) for d in symbol.decorators)
+        if is_crate_main or is_async_main:
+            hints.append(
+                EntrypointHint(
+                    rule_id="rust.core.main",
+                    kind=EntrypointKind.MAIN,
+                    handler_qualified_name=symbol.qualified_name,
+                    name=symbol.qualified_name,
+                    span=symbol.span,
+                    framework=None,
+                )
+            )
+    return hints
+
+
+def _axum_routes(x: FileExtraction) -> list[EntrypointHint]:
+    """`Router::new().route("/x", post(handler))` — the handler is buried in the
+    second argument, so we regex it out of the preview but can't statically bind
+    it (the Express-rule fidelity tradeoff)."""
+    hints = []
+    for ref in x.references:
+        if ref.kind != "call" or ref.callee_name != "route" or not ref.arg_preview:
+            continue
+        route = first_string_arg("(" + ref.arg_preview.lstrip("("))
+        if route is None or not route.startswith("/"):
+            continue
+        method, handler = _axum_method_and_handler(ref.arg_preview)
+        hints.append(
+            EntrypointHint(
+                rule_id="rust.axum.route",
+                kind=EntrypointKind.HTTP_ROUTE,
+                handler_qualified_name=None,
+                route=route,
+                http_methods=[method],
+                framework="axum",
+                metadata={"handler_text": handler, "registration": ref.arg_preview},
+            )
+        )
+    return hints
+
+
+_AXUM_HANDLER = re.compile(
+    r"\b(get|post|put|delete|patch|head|options)\s*\(\s*([A-Za-z_]\w*)"
+)
+
+
+def _axum_method_and_handler(preview: str) -> tuple[str, str | None]:
+    match = _AXUM_HANDLER.search(preview)
+    if match:
+        return match.group(1).upper(), match.group(2)
+    return "*", None
+
+
+def _route_attr_rule(framework: str):
+    """actix-web and rocket both register routes with `#[get("/x")]`-style
+    attribute macros on the handler function; one matcher, framework by param."""
+
+    def matcher(x: FileExtraction) -> list[EntrypointHint]:
+        hints = []
+        for symbol in x.symbols:
+            if symbol.kind not in (SymbolKind.FUNCTION, SymbolKind.METHOD):
+                continue
+            for decorator in symbol.decorators:
+                m = _ROUTE_ATTR.match(decorator)
+                if not m:
+                    continue
+                verb = _VERB.get(m.group(1), "*")
+                hints.append(
+                    EntrypointHint(
+                        rule_id=f"rust.{framework}.route",
+                        kind=EntrypointKind.HTTP_ROUTE,
+                        handler_qualified_name=symbol.qualified_name,
+                        route=first_string_arg(decorator) or "",
+                        http_methods=[verb],
+                        framework=framework,
+                        span=symbol.span,
+                    )
+                )
+        return hints
+
+    return matcher
+
+
+def _clap_commands(x: FileExtraction) -> list[EntrypointHint]:
+    hints = []
+    for symbol in x.symbols:
+        if symbol.kind not in (SymbolKind.STRUCT, SymbolKind.CLASS):
+            continue
+        if any(_DERIVE_PARSER.match(d) for d in symbol.decorators):
+            hints.append(
+                EntrypointHint(
+                    rule_id="rust.clap.command",
+                    kind=EntrypointKind.CLI_COMMAND,
+                    handler_qualified_name=symbol.qualified_name,
+                    name=symbol.name,
+                    framework="clap",
+                    span=symbol.span,
+                )
+            )
+    return hints
+
+
+register(EntrypointRule("rust.core.main", "rust", None,
+                        EntrypointKind.MAIN, _rust_main))
+register(EntrypointRule("rust.axum.route", "rust", "axum",
+                        EntrypointKind.HTTP_ROUTE, _axum_routes))
+register(EntrypointRule("rust.actix.route", "rust", "actix-web",
+                        EntrypointKind.HTTP_ROUTE, _route_attr_rule("actix-web")))
+register(EntrypointRule("rust.rocket.route", "rust", "rocket",
+                        EntrypointKind.HTTP_ROUTE, _route_attr_rule("rocket")))
+register(EntrypointRule("rust.clap.command", "rust", "clap",
+                        EntrypointKind.CLI_COMMAND, _clap_commands))