reware-lighthouse 0.1.0__py3-none-any.whl

lighthouse_cli/__init__.py

@@ -0,0 +1,9 @@
+"""Lighthouse developer CLI."""
+
+
+def __getattr__(name: str) -> str:
+    if name == "__version__":
+        from lighthouse_cli.identity import version
+
+        return version()
+    raise AttributeError(name)

lighthouse_cli/__main__.py

@@ -0,0 +1,4 @@
+from lighthouse_cli.cli import run
+
+if __name__ == "__main__":
+    raise SystemExit(run())

lighthouse_cli/api.py

@@ -0,0 +1,39 @@
+"""Typed wrappers over the Lighthouse product API endpoints the CLI uses."""
+
+from typing import Any, TypedDict
+
+from lighthouse_cli.config import ClientConfig
+from lighthouse_cli.git_remote import normalize_repo_full_name
+from lighthouse_cli.http import get_json
+
+
+class Project(TypedDict, total=False):
+    name: str
+    slug: str
+    repo_full_name: str | None
+
+
+def whoami(config: ClientConfig) -> dict[str, Any]:
+    """GET /v1/me — verify the API key and return {user, team}."""
+    body = get_json(config, "/v1/me")
+    return body if isinstance(body, dict) else {}
+
+
+def list_projects(config: ClientConfig) -> list[Project]:
+    """GET /v1/projects — the team's registered projects."""
+    body = get_json(config, "/v1/projects")
+    return [p for p in body if isinstance(p, dict)] if isinstance(body, list) else []
+
+
+def match_project(projects: list[Project], identifier: str) -> Project | None:
+    """Find the project whose repo_full_name or slug matches the identifier."""
+    wanted = identifier.strip().lower()
+    normalized = normalize_repo_full_name(identifier) or wanted
+    for project in projects:
+        repo = (project.get("repo_full_name") or "").lower()
+        if (repo and repo == normalized) or project.get("slug", "").lower() == wanted:
+            return project
+    return None
+
+
+__all__ = ["Project", "list_projects", "match_project", "whoami"]

lighthouse_cli/cli.py

@@ -0,0 +1,100 @@
+"""The `reware-lighthouse` command dispatcher.
+
+Each subcommand owns its own argument parsing, so the dispatcher just routes the
+first token and forwards the rest. New subcommands register in ``_COMMANDS``.
+"""
+
+import sys
+from collections.abc import Callable
+
+from lighthouse_cli import ui
+from lighthouse_cli.commands import deinit, init, login, logout, scan, status
+from lighthouse_cli.config import ClientConfigError
+from lighthouse_cli.http import ClientRequestError
+from lighthouse_cli.identity import COMMAND, NotInstalledError, version
+from lighthouse_cli.link import LinkError
+from lighthouse_cli.mcp import run as run_mcp
+
+_COMMANDS: dict[str, Callable[[list[str]], int]] = {
+    "login": login.run,
+    "logout": logout.run,
+    "init": init.run,
+    "deinit": deinit.run,
+    "scan": scan.run,
+    "status": status.run,
+    "mcp": run_mcp,
+}
+
+_USAGE = f"""{COMMAND} — developer CLI for Lighthouse
+
+Usage: {COMMAND} <command> [options]
+       {COMMAND} --version
+
+Commands:
+  login    Store and verify your API key
+  logout   Remove the saved API key
+  init     Link this repository to a project and set up tooling
+  deinit   Remove what init set up in this repository
+  scan     Run the pre-commit security scan
+  status   Check your account, project and tooling (exit 0 means it works)
+  mcp      Run the stdio MCP server (usually launched by your coding agent)
+  help     Show help for a command: {COMMAND} help <command>
+
+Prompt enhancement runs only when you ask for it in your coding agent:
+/lighthouse-enhance <request> in Claude Code, the lighthouse-enhance skill in Codex.
+
+Run `{COMMAND} <command> --help` for command-specific options."""
+
+
+def _print_version(_argv: list[str]) -> int:
+    print(f"{COMMAND} {version()}")
+    return 0
+
+
+_ORDINARY = (ClientConfigError, ClientRequestError, LinkError, OSError, ui.NoTerminalError)
+_OWN_ERRORS = frozenset({"scan", "mcp"})  # scan fails open itself; mcp owns stdout
+
+
+def _guarded(
+    handler: Callable[[list[str]], int], argv: list[str], *, ordinary: bool = False
+) -> int:
+    try:
+        return handler(argv)
+    except NotInstalledError as exc:
+        print(f"{COMMAND}: {exc}", file=sys.stderr)
+        return 1
+    except Exception as exc:
+        if not (ordinary and isinstance(exc, _ORDINARY)):
+            raise
+        ui.error(str(exc))
+        return 2 if isinstance(exc, ui.NoTerminalError) else 1
+    except KeyboardInterrupt:
+        if not ordinary:
+            raise
+        print("Interrupted.", file=sys.stderr)
+        return 130
+
+
+def run(argv: list[str] | None = None) -> int:
+    for stream in (sys.stdout, sys.stderr):
+        # A git hook on Windows pipes output through a legacy codepage that lacks ✓ and •.
+        if hasattr(stream, "reconfigure"):
+            stream.reconfigure(errors="replace")
+    args = list(sys.argv[1:] if argv is None else argv)
+    if args[:1] == ["help"] and len(args) > 1:
+        args = [args[1], "--help"]
+    if not args or args[0] in {"-h", "--help", "help"}:
+        print(_USAGE)
+        return 0
+    if args[0] in {"-V", "--version"}:
+        return _guarded(_print_version, [])
+    command, rest = args[0], args[1:]
+    handler = _COMMANDS.get(command)
+    if handler is None:
+        print(f"{COMMAND}: unknown command '{command}'.\n\n{_USAGE}", file=sys.stderr)
+        return 2
+    return _guarded(handler, rest, ordinary=command not in _OWN_ERRORS)
+
+
+if __name__ == "__main__":
+    raise SystemExit(run())

lighthouse_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""`lighthouse` subcommands."""

lighthouse_cli/commands/deinit.py

@@ -0,0 +1,57 @@
+"""`lighthouse deinit` — undo what `init` set up in this repository.
+
+Removes only content `init` recorded and the developer has not edited. Saved credentials
+(`logout`), scan reports and the installed tool are left alone.
+"""
+
+import contextlib
+from pathlib import Path
+
+from lighthouse_cli import ui
+from lighthouse_cli.config import has_saved_api_key
+from lighthouse_cli.git_remote import git_toplevel
+from lighthouse_cli.identity import COMMAND
+from lighthouse_cli.link import LINK_DIR, LinkError, remove_link
+from lighthouse_cli.parsing import parser
+from lighthouse_cli.setup import remove
+
+
+def _remove_link(root: Path) -> bool:
+    try:
+        path = remove_link(root)
+    except (LinkError, OSError) as exc:
+        ui.warn(f"Left the project link as is: {exc}")
+        return False
+    if path:
+        ui.success(f"Removed {path}.")
+    with contextlib.suppress(OSError):
+        (root / LINK_DIR).rmdir()  # only succeeds when nothing else lives there
+    return True
+
+
+def run(argv: list[str] | None = None) -> int:
+    parser("deinit", "Remove what init set up in this repository.", "deinit").parse_args(argv)
+
+    root_path = git_toplevel()
+    if root_path is None:
+        ui.error(f"Run `{COMMAND} deinit` from inside a Git repository.")
+        return 1
+    root = Path(root_path)
+
+    report = remove(root)
+    for step in report.steps:
+        (ui.success if step.ok else ui.warn)(step.message)
+    linked = _remove_link(root)
+    if not report.complete or not linked:
+        ui.error("Cleanup is incomplete. Finish the items above by hand.")
+        return 1
+    if has_saved_api_key():
+        ui.hint(
+            f"Your API key stays saved (`{COMMAND} logout` removes it) and scan reports are kept."
+        )
+    else:
+        ui.hint("Scan reports are kept.")
+    return 0
+
+
+__all__ = ["run"]

lighthouse_cli/commands/init.py

@@ -0,0 +1,137 @@
+"""`lighthouse init` — link this checkout to a dashboard project and wire up tooling.
+
+One guided command: verify the API key, confirm the repository, match it to a
+registered project, write the ``.lighthouse/project.toml`` link, then optionally
+install the pre-commit hook and write the Claude/Codex MCP config and enhance skill.
+"""
+
+import argparse
+from pathlib import Path
+
+from lighthouse_cli import ui
+from lighthouse_cli.api import Project, list_projects, match_project
+from lighthouse_cli.commands.login import ensure_login
+from lighthouse_cli.config import ClientConfig, ClientConfigError
+from lighthouse_cli.git_remote import detect_local_repo, git_toplevel
+from lighthouse_cli.http import ClientRequestError
+from lighthouse_cli.identity import COMMAND
+from lighthouse_cli.link import ProjectLink, write_link
+from lighthouse_cli.parsing import parser
+from lighthouse_cli.setup import Integration, SetupReport, install
+
+
+def _choose_identifier(args: argparse.Namespace, root: Path) -> str:
+    if args.project:
+        return args.project
+    detected = detect_local_repo(str(root))
+    if args.yes:
+        if not detected:
+            raise ClientConfigError(
+                "Could not detect a Git remote. Re-run with --project owner/name."
+            )
+        return detected
+    return ui.prompt(
+        "Project (owner/name)", default=detected or None, needs="--project or --yes"
+    ) or (detected or "")
+
+
+def _verify(config: ClientConfig, identifier: str) -> Project:
+    projects = list_projects(config)
+    match = match_project(projects, identifier)
+    if match is not None:
+        return match
+    ui.error(f"No Lighthouse project matches '{identifier}'.")
+    if projects:
+        available = ", ".join(sorted(p.get("repo_full_name", p.get("slug", "?")) for p in projects))
+        ui.hint(f"Projects on your team: {available}")
+    ui.hint(f"Add this repository on the Lighthouse dashboard, then re-run `{COMMAND} init`.")
+    raise SystemExit(1)
+
+
+_AGENTS = {
+    "claude": (Integration.CLAUDE, Integration.CLAUDE_SKILL),
+    "codex": (Integration.CODEX, Integration.CODEX_SKILL),
+}
+
+
+def _requested(args: argparse.Namespace) -> list[Integration]:
+    requested = []
+    if not args.no_hook and (
+        args.yes or ui.confirm("Install the pre-commit hook?", needs="--yes or --no-hook")
+    ):
+        requested.append(Integration.HOOK)
+    if args.no_mcp:
+        return requested
+    if args.agent:
+        agents = {"claude", "codex"} if args.agent == "both" else {args.agent}
+    elif args.yes:
+        agents = {"claude", "codex"}
+    else:
+        agents = set()
+        if ui.confirm(
+            "Set up Claude Code (.mcp.json and the /lighthouse-enhance skill)?",
+            needs="--agent, --yes or --no-mcp",
+        ):
+            agents.add("claude")
+        if ui.confirm(
+            "Set up Codex (.codex/config.toml and the lighthouse-enhance skill)?",
+            needs="--agent, --yes or --no-mcp",
+        ):
+            agents.add("codex")
+    return [*requested, *(integration for name in sorted(agents) for integration in _AGENTS[name])]
+
+
+def _report(report: SetupReport) -> None:
+    for step in report.steps:
+        (ui.success if step.ok else ui.warn)(step.message)
+    if not report.complete:
+        pending = ", ".join(f"{s.integration.value} ({s.outcome.value})" for s in report.pending)
+        ui.error(f"Setup is incomplete. Pending: {pending}.")
+        ui.hint(f"Fix the items above, then re-run `{COMMAND} init`; finished steps are kept.")
+
+
+def run(argv: list[str] | None = None) -> int:
+    cli = parser("init", "Link this repo to Lighthouse and set up tooling.", "init --yes")
+    cli.add_argument("--project", default=None, help="Project owner/name (skips detection).")
+    cli.add_argument("--yes", "-y", action="store_true", help="Accept all prompts.")
+    cli.add_argument("--no-hook", action="store_true", help="Skip the pre-commit hook.")
+    cli.add_argument("--no-mcp", action="store_true", help="Skip the agent MCP config and skill.")
+    cli.add_argument("--agent", choices=["claude", "codex", "both"], default=None)
+    args = cli.parse_args(argv)
+
+    root_path = git_toplevel()
+    if root_path is None:
+        ui.error(f"Run `{COMMAND} init` from inside a Git repository.")
+        return 1
+    root = Path(root_path)
+
+    try:
+        config = ensure_login(assume_yes=args.yes)
+        identifier = _choose_identifier(args, root)
+        if not identifier:
+            ui.error("A project identifier is required.")
+            return 1
+        project = _verify(config, identifier)
+    except (ClientConfigError, ClientRequestError) as exc:
+        ui.error(str(exc))
+        return 1
+
+    repo_full_name = project.get("repo_full_name") or identifier
+    link_path = write_link(root, ProjectLink(project=repo_full_name))
+    ui.success(f"Linked to '{project.get('name', repo_full_name)}' ({repo_full_name})")
+    ui.hint(f"Wrote {link_path}")
+
+    report = install(root, repo_full_name, _requested(args))
+    _report(report)
+    if not report.complete:
+        return 1
+
+    ui.heading("Done. Next steps:")
+    ui.hint("• Restart your coding agent, then use /lighthouse-enhance (Claude) or the")
+    ui.hint("  lighthouse-enhance skill (Codex) to enhance a request.")
+    ui.hint("• Stage a change and commit to see a scan report in .lighthouse/findings/.")
+    ui.hint(f"• Run `{COMMAND} status` any time to check this setup.")
+    return 0
+
+
+__all__ = ["run"]

lighthouse_cli/commands/login.py

@@ -0,0 +1,99 @@
+"""`reware-lighthouse login` — store and verify the per-user API key.
+
+Verifies the key against ``GET /v1/me`` and only then writes it to
+``~/.config/lighthouse/config.env`` (0600). The endpoint is ``--api-base``, then
+``LIGHTHOUSE_API_BASE_URL``, then the saved value, then the production default.
+`init` reuses ``ensure_login`` so a first-time developer is prompted for a key inline.
+"""
+
+import os
+import sys
+
+from lighthouse_cli import ui
+from lighthouse_cli.api import whoami
+from lighthouse_cli.config import (
+    ClientConfig,
+    ClientConfigError,
+    load_client_config,
+    normalize_api_base_url,
+    resolve_api_base_url,
+    save_client_config,
+)
+from lighthouse_cli.http import ClientRequestError
+from lighthouse_cli.parsing import parser
+
+
+def _describe(identity: dict) -> str:
+    user = identity.get("user", {})
+    team = identity.get("team", {})
+    name = user.get("full_name") or user.get("email") or "your account"
+    role = user.get("role")
+    role_suffix = f" ({role})" if role else ""
+    return f"Signed in as {name}{role_suffix} · team {team.get('name', '?')}"
+
+
+def resolve_and_verify(api_key: str, api_base_url: str) -> tuple[ClientConfig, dict]:
+    """Build a config, confirm it against the API, and return (config, identity)."""
+    config = ClientConfig(api_key=api_key, api_base_url=normalize_api_base_url(api_base_url))
+    identity = whoami(config)
+    return config, identity
+
+
+def _verify_and_save(api_key: str, api_base_url: str) -> ClientConfig:
+    config, identity = resolve_and_verify(api_key, api_base_url)
+    path = save_client_config(config)
+    ui.success(_describe(identity))
+    ui.hint(f"Saved to {path}")
+    return config
+
+
+def _prompt_key(needs: str) -> str:
+    api_key = ui.secret("API key (from your dashboard — reveal once)", needs=needs)
+    if not api_key:
+        raise ClientConfigError("An API key is required.")
+    return api_key
+
+
+def ensure_login(*, assume_yes: bool = False) -> ClientConfig:
+    """Return a working config, prompting for a key if none is configured.
+
+    Raises ``ClientConfigError`` when non-interactive and no key is available.
+    """
+    try:
+        config = load_client_config()
+        whoami(config)  # cheap check that the stored key still works
+        return config
+    except ClientConfigError:
+        if assume_yes:
+            raise
+        ui.warn("No Lighthouse API key configured yet.")
+        return _verify_and_save(
+            _prompt_key("LIGHTHOUSE_API_KEY or `login --api-key`"), resolve_api_base_url()
+        )
+
+
+def run(argv: list[str] | None = None) -> int:
+    cli = parser("login", "Store and verify your API key.", "login --api-key <key>")
+    cli.add_argument(
+        "--api-key", default=None, help="API key (otherwise LIGHTHOUSE_API_KEY, or prompted)."
+    )
+    cli.add_argument("--api-base", default=None, help="Lighthouse API base URL.")
+    cli.add_argument("--yes", "-y", action="store_true", help="Never prompt.")
+    args = cli.parse_args(argv)
+
+    try:
+        api_base = args.api_base or resolve_api_base_url()
+        api_key = args.api_key or os.environ.get("LIGHTHOUSE_API_KEY") or ""
+        if not api_key:
+            if args.yes or sys.stdin is None or not sys.stdin.isatty():
+                ui.error("No API key. Pass --api-key or set LIGHTHOUSE_API_KEY.")
+                return 2
+            api_key = _prompt_key("--api-key or LIGHTHOUSE_API_KEY")
+        _verify_and_save(api_key, api_base)
+    except (ClientConfigError, ClientRequestError) as exc:
+        ui.error(str(exc))
+        return 1
+    return 0
+
+
+__all__ = ["ensure_login", "resolve_and_verify", "run"]

lighthouse_cli/commands/logout.py

@@ -0,0 +1,24 @@
+"""`reware-lighthouse logout` — remove the saved API key from this machine."""
+
+import os
+
+from lighthouse_cli import ui
+from lighthouse_cli.config import ClientConfigError, clear_api_key
+from lighthouse_cli.parsing import parser
+
+
+def run(argv: list[str] | None = None) -> int:
+    parser("logout", "Remove the saved API key.", "logout").parse_args(argv)
+    try:
+        removed = clear_api_key()
+    except ClientConfigError as exc:
+        ui.error(str(exc))
+        return 1
+    ui.success("Removed the saved API key." if removed else "No saved API key to remove.")
+    if os.environ.get("LIGHTHOUSE_API_KEY"):
+        ui.warn("LIGHTHOUSE_API_KEY is set in your environment and stays active.")
+    ui.hint("Repository setup is unchanged. Revoke the key itself from the dashboard.")
+    return 0
+
+
+__all__ = ["run"]