logify360 1.0.0__py3-none-any.whl

logify360/cli/colors.py

@@ -0,0 +1,65 @@
+"""Tiny ANSI color helpers, a stdlib-only stand-in for picocolors.
+
+Colors are disabled automatically when:
+
+  * ``NO_COLOR`` is set (https://no-color.org/), or
+  * ``stdout`` is not a TTY (piped / redirected / CI without a terminal).
+
+Keeping this dependency-free matters: installing logify360 should not
+pull a color library just so the SDK is importable.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+_RESET = "\033[0m"
+
+
+def _enabled() -> bool:
+    if os.environ.get("NO_COLOR") is not None:
+        return False
+    if os.environ.get("FORCE_COLOR") is not None:
+        return True
+    try:
+        return sys.stdout.isatty()
+    except Exception:
+        return False
+
+
+def _wrap(code: str, text: str) -> str:
+    if not _enabled():
+        return text
+    return f"\033[{code}m{text}{_RESET}"
+
+
+def bold(text: str) -> str:
+    return _wrap("1", text)
+
+
+def dim(text: str) -> str:
+    return _wrap("2", text)
+
+
+def underline(text: str) -> str:
+    return _wrap("4", text)
+
+
+def red(text: str) -> str:
+    return _wrap("31", text)
+
+
+def green(text: str) -> str:
+    return _wrap("32", text)
+
+
+def yellow(text: str) -> str:
+    return _wrap("33", text)
+
+
+def cyan(text: str) -> str:
+    return _wrap("36", text)
+
+
+__all__ = ["bold", "cyan", "dim", "green", "red", "underline", "yellow"]

logify360/cli/env_writer.py

@@ -0,0 +1,100 @@
+"""Idempotently add or update a ``KEY=VALUE`` line in a ``.env`` file.
+
+Mirrors ``packages/cli/src/env-writer.ts`` so the Python and Node wizards
+behave identically:
+
+  * Existing lines and comments are preserved.
+  * If ``KEY`` already exists, its value is replaced in place.
+  * If the file does not exist, it is created.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from dataclasses import dataclass
+from typing import Optional
+
+#: Owner read/write only - env files carry the customer's API key (CLI-02).
+_ENV_FILE_MODE = 0o600
+
+
+@dataclass(frozen=True)
+class UpsertResult:
+    changed: bool
+    created: bool
+    existed: bool
+
+
+def read_env_var(cwd: str, filename: str, key: str) -> Optional[str]:
+    r"""Return the current value of ``key`` in the env file, or ``None``.
+
+    ``None`` also covers an empty or blank value. The whitespace around ``=`` is
+    ``[ \t]``, never ``\s``: ``\s`` also matches the newline, so ``KEY=`` with nothing
+    after it used to return the NEXT line (``OTHER=1``) as if it were the key.
+    """
+    path = os.path.join(cwd, filename)
+    if not os.path.isfile(path):
+        return None
+    try:
+        with open(path, encoding="utf-8") as fh:
+            text = fh.read()
+    except OSError:
+        return None
+    match = re.search(rf"^{re.escape(key)}[ \t]*=[ \t]*(.+)$", text, re.MULTILINE)
+    return (match.group(1).strip() or None) if match else None
+
+
+def upsert_env_var(cwd: str, filename: str, key: str, value: str) -> UpsertResult:
+    path = os.path.join(cwd, filename)
+    existed = os.path.isfile(path)
+    existing = ""
+    if existed:
+        try:
+            with open(path, encoding="utf-8") as fh:
+                existing = fh.read()
+        except OSError:
+            existing = ""
+
+    lines = existing.split("\n") if existing else []
+    pattern = re.compile(rf"^{re.escape(key)}\s*=")
+    found = False
+    value_changed = False
+    new_line = f"{key}={value}"
+
+    updated = []
+    for line in lines:
+        if pattern.match(line):
+            found = True
+            if line != new_line:
+                value_changed = True
+            updated.append(new_line)
+        else:
+            updated.append(line)
+
+    if not found:
+        if updated and updated[-1] != "":
+            updated.append("")
+        updated.append(new_line)
+        updated.append("")  # trailing newline
+
+    next_text = "\n".join(updated)
+    if next_text == existing:
+        return UpsertResult(changed=False, created=False, existed=existed)
+
+    # CLI-02: the file holds the customer's sl_live_* key - owner read/write
+    # only, on create and on update alike (an existing 0644 file is tightened).
+    fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, _ENV_FILE_MODE)
+    with os.fdopen(fd, "w", encoding="utf-8") as fh:
+        fh.write(next_text)
+    if existed and os.name != "nt":
+        os.chmod(path, _ENV_FILE_MODE)
+
+    return UpsertResult(
+        changed=value_changed if found else True,
+        created=not existed,
+        existed=existed,
+    )
+
+
+__all__ = ["UpsertResult", "read_env_var", "upsert_env_var"]

logify360/cli/framework_detect.py

@@ -0,0 +1,183 @@
+"""Detect the Python project layout and which LLM libraries it already uses.
+
+Unlike the Node CLI (Next.js-centric), Python projects vary widely in their
+package manager and manifest. We sniff the common ones and, crucially, figure
+out which provider SDKs (``openai`` / ``anthropic`` / ``google-generativeai``)
+are declared so the wizard can suggest the right integrations even before the
+Logify360 key tells us which provider keys are registered.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+try:  # Python 3.11+ ships tomllib; older versions degrade to a regex sniff.
+    import tomllib  # type: ignore[import-not-found]
+except ModuleNotFoundError:  # pragma: no cover - exercised on <3.11 only
+    tomllib = None
+
+
+# Maps the Logify360 provider name to the PyPI distribution names that imply it.
+PROVIDER_LIBRARIES = {
+    "openai": ("openai",),
+    "anthropic": ("anthropic",),
+    "gemini": ("google-generativeai", "google-genai"),
+}
+
+
+@dataclass(frozen=True)
+class ProjectInfo:
+    """Everything the wizard learned by looking at the filesystem."""
+
+    package_manager: str  # 'poetry' | 'uv' | 'pipenv' | 'pip' | 'unknown'
+    manifest: Optional[str]  # the file we read deps from, if any
+    env_file: str  # preferred env file to write to (always '.env' for Python)
+    detected_providers: List[str] = field(default_factory=list)
+
+
+def detect_project(cwd: Optional[str] = None) -> ProjectInfo:
+    root = cwd or os.getcwd()
+
+    pm, manifest = _detect_package_manager(root)
+    providers = _detect_providers(root)
+
+    return ProjectInfo(
+        package_manager=pm,
+        manifest=manifest,
+        env_file=".env",
+        detected_providers=providers,
+    )
+
+
+def _exists(root: str, name: str) -> bool:
+    return os.path.isfile(os.path.join(root, name))
+
+
+def _detect_package_manager(root: str) -> tuple[str, Optional[str]]:
+    """Lockfiles are the most reliable signal; fall back to manifests."""
+    if _exists(root, "poetry.lock"):
+        return "poetry", "pyproject.toml"
+    if _exists(root, "uv.lock"):
+        return "uv", "pyproject.toml"
+    if _exists(root, "Pipfile.lock") or _exists(root, "Pipfile"):
+        return "pipenv", "Pipfile"
+
+    if _exists(root, "pyproject.toml"):
+        # A pyproject with [tool.poetry] means poetry even without a lockfile.
+        text = _read(os.path.join(root, "pyproject.toml"))
+        if text and "[tool.poetry]" in text:
+            return "poetry", "pyproject.toml"
+        return "pip", "pyproject.toml"
+
+    if _exists(root, "requirements.txt"):
+        return "pip", "requirements.txt"
+
+    return "unknown", None
+
+
+def _read(path: str) -> Optional[str]:
+    try:
+        with open(path, encoding="utf-8") as fh:
+            return fh.read()
+    except OSError:
+        return None
+
+
+def _detect_providers(root: str) -> List[str]:
+    """Collect declared dependencies across every manifest we can find, then
+    map distribution names back to Logify360 provider names."""
+    declared = set()
+
+    declared |= _deps_from_pyproject(os.path.join(root, "pyproject.toml"))
+    declared |= _deps_from_requirements(os.path.join(root, "requirements.txt"))
+    declared |= _deps_from_pipfile(os.path.join(root, "Pipfile"))
+
+    found: List[str] = []
+    for provider, dists in PROVIDER_LIBRARIES.items():
+        if any(_normalize(d) in declared for d in dists):
+            found.append(provider)
+    return found
+
+
+def _normalize(name: str) -> str:
+    # PEP 503 normalization so 'Google-GenerativeAI' == 'google-generativeai'.
+    return re.sub(r"[-_.]+", "-", name).strip().lower()
+
+
+def _deps_from_pyproject(path: str) -> set[str]:
+    text = _read(path)
+    if text is None:
+        return set()
+
+    names: set[str] = set()
+    if tomllib is not None:
+        try:
+            data = tomllib.loads(text)
+        except Exception:
+            data = {}
+        # PEP 621 [project].dependencies + optional-dependencies
+        project = data.get("project", {}) if isinstance(data, dict) else {}
+        for spec in project.get("dependencies", []) or []:
+            names.add(_dist_from_spec(spec))
+        for group in (project.get("optional-dependencies", {}) or {}).values():
+            for spec in group or []:
+                names.add(_dist_from_spec(spec))
+        # Poetry [tool.poetry.dependencies] is a table keyed by dist name.
+        poetry = (
+            data.get("tool", {}).get("poetry", {}) if isinstance(data, dict) else {}
+        )
+        for key in (poetry.get("dependencies", {}) or {}):
+            names.add(_normalize(key))
+        for group in (poetry.get("group", {}) or {}).values():
+            for key in (group.get("dependencies", {}) or {}):
+                names.add(_normalize(key))
+    else:  # pragma: no cover - <3.11 fallback
+        for spec in re.findall(r'"([A-Za-z0-9._-]+(?:\[[^\]]*\])?[^"]*)"', text):
+            names.add(_dist_from_spec(spec))
+
+    names.discard("")
+    return names
+
+
+def _deps_from_requirements(path: str) -> set[str]:
+    text = _read(path)
+    if text is None:
+        return set()
+    names: set[str] = set()
+    for line in text.splitlines():
+        line = line.strip()
+        if not line or line.startswith("#") or line.startswith("-"):
+            continue
+        names.add(_dist_from_spec(line))
+    names.discard("")
+    return names
+
+
+def _deps_from_pipfile(path: str) -> set[str]:
+    text = _read(path)
+    if text is None:
+        return set()
+    # Pipfile is TOML but commonly read loosely; grab the bare package names
+    # under [packages] / [dev-packages] via a simple key sniff.
+    names: set[str] = set()
+    for match in re.finditer(r'^\s*"?([A-Za-z0-9._-]+)"?\s*=', text, re.MULTILINE):
+        names.add(_normalize(match.group(1)))
+    names.discard("")
+    return names
+
+
+def _dist_from_spec(spec: str) -> str:
+    """Extract the distribution name from a PEP 508 requirement string.
+
+    ``openai>=1.0.0`` → ``openai``; ``logify360[openai]`` → ``logify360``.
+    """
+    spec = spec.strip()
+    # Cut at the first version / marker / extras delimiter.
+    name = re.split(r"[\s<>=!~\[;@(]", spec, maxsplit=1)[0]
+    return _normalize(name)
+
+
+__all__ = ["PROVIDER_LIBRARIES", "ProjectInfo", "detect_project"]

logify360/cli/installer.py

@@ -0,0 +1,143 @@
+"""Install the ``logify360`` provider extras into the user's project.
+
+The ``logify360`` distribution is the SDK *and* this CLI, so the user already
+has it on their machine to run ``logify360 init``. What this step does is make
+it a declared dependency of their project and pull the right provider extras
+(``logify360[openai]`` etc.) using whichever package manager they use.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import shlex
+import subprocess  # noqa: S404 - we build argv lists ourselves, never shell strings
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Optional, Sequence
+
+# Logify360 provider name → extras key in pyproject [project.optional-dependencies].
+PROVIDER_EXTRAS = {
+    "openai": "openai",
+    "anthropic": "anthropic",
+    "gemini": "gemini",
+}
+
+
+@dataclass(frozen=True)
+class InstallResult:
+    ok: bool
+    command: str
+    error: Optional[str] = None
+
+
+def resolve_sdk_artifact(cwd: str, artifact: Optional[str]) -> Optional[str]:
+    """Local dashboard wheel, or None to install ``logify360`` from PyPI."""
+    if not artifact:
+        return None
+    path = (Path(cwd) / artifact).resolve()
+    if path.is_file() and re.fullmatch(r"logify360-[0-9][^-]*-py3-none-any\.whl", path.name):
+        return str(path)
+    raise ValueError(
+        "Expected a local SDK wheel named logify360-<version>-py3-none-any.whl, "
+        "or omit --sdk-artifact to install logify360 from PyPI."
+    )
+
+
+def install_target(providers: Sequence[str], artifact: Optional[str] = None) -> str:
+    """Append provider extras to a wheel path or the PyPI package name."""
+    base = artifact or "logify360"
+    extras = sorted({PROVIDER_EXTRAS[p] for p in providers if p in PROVIDER_EXTRAS})
+    if not extras:
+        return base
+    return f"{base}[{','.join(extras)}]"
+
+
+def _install_argv(package_manager: str, target: str) -> List[str]:
+    if package_manager == "poetry":
+        return ["poetry", "add", target]
+    if package_manager == "uv":
+        return ["uv", "add", target]
+    if package_manager == "pipenv":
+        return ["pipenv", "install", target]
+    # pip (and 'unknown') uses the active interpreter so we install into the
+    # same environment the CLI is running from.
+    return [sys.executable, "-m", "pip", "install", target]
+
+
+def install_logify360(
+    cwd: str,
+    package_manager: str,
+    providers: Sequence[str],
+    *,
+    sdk_artifact: Optional[str] = None,
+    dry_run: bool = False,
+    timeout: int = 300,
+) -> InstallResult:
+    try:
+        artifact = resolve_sdk_artifact(cwd, sdk_artifact)
+    except ValueError as exc:
+        return InstallResult(ok=False, command="", error=str(exc))
+    target = install_target(providers, artifact)
+    argv = _install_argv(package_manager, target)
+    command = shlex.join(
+        argv if argv[0] != sys.executable else ["python", "-m", "pip", "install", target]
+    )
+
+    if dry_run:
+        return InstallResult(ok=True, command=command)
+
+    try:
+        proc = subprocess.run(  # noqa: S603 - argv is a fixed list, no shell
+            argv,
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            check=False,
+        )
+    except FileNotFoundError:
+        return InstallResult(
+            ok=False,
+            command=command,
+            error=f"{package_manager} not found on PATH",
+        )
+    except subprocess.TimeoutExpired:
+        return InstallResult(ok=False, command=command, error="install timed out")
+
+    if proc.returncode == 0:
+        return InstallResult(ok=True, command=command)
+
+    detail = (proc.stderr or proc.stdout or "").strip()
+    return InstallResult(
+        ok=False,
+        command=command,
+        error=f"exited with code {proc.returncode}{f': {detail[:200]}' if detail else ''}",
+    )
+
+
+def is_logify360_declared(cwd: str) -> bool:
+    """Best-effort check for an existing ``logify360`` dependency in a manifest."""
+    for manifest in ("pyproject.toml", "requirements.txt", "Pipfile"):
+        path = os.path.join(cwd, manifest)
+        if not os.path.isfile(path):
+            continue
+        try:
+            with open(path, encoding="utf-8") as fh:
+                text = fh.read()
+        except OSError:
+            continue
+        # Match the package name as a token, not a substring of another word.
+        if re.search(r"(?<![\w-])logify360(?![\w-])", text):
+            return True
+    return False
+
+
+__all__ = [
+    "PROVIDER_EXTRAS",
+    "InstallResult",
+    "install_logify360",
+    "install_target",
+    "is_logify360_declared",
+]

logify360/cli/key_info.py

@@ -0,0 +1,83 @@
+"""Validate a Logify360 key against the API and introspect its providers.
+
+Hits ``GET /api/v1/me/key-info`` exactly like ``packages/cli`` does. The
+endpoint authenticates with the ``sl_live_*`` key in the ``Authorization``
+header (no Supabase session) and returns which provider keys are registered
+under that Logify360 key, so the wizard knows which integrations to patch.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+import httpx
+
+from .._base_url import _api_key_problem
+
+
+class KeyInfoError(Exception):
+    """A user-actionable failure validating the key (network or API)."""
+
+
+@dataclass(frozen=True)
+class KeyInfo:
+    project_id: Optional[str]
+    project_name: Optional[str]
+    providers: List[str] = field(default_factory=list)
+    scope: str = "full"
+
+
+def fetch_key_info(api_key: str, api_base: str, *, timeout: float = 15.0) -> KeyInfo:
+    # The key goes into a header, and the error httpx raises for an illegal header value
+    # quotes it. Refuse a malformed key here, before any request, whoever the caller is.
+    problem = _api_key_problem(api_key, "The key")
+    if problem:
+        raise KeyInfoError(f"{problem}. Copy the key again from the dashboard.")
+
+    url = f"{api_base.rstrip('/')}/api/v1/me/key-info"
+    try:
+        response = httpx.get(
+            url,
+            headers={"Authorization": f"Bearer {api_key}"},
+            timeout=timeout,
+        )
+    except httpx.HTTPError as exc:
+        # The exception CLASS, never its text: for a bad header that text is the header,
+        # and the header is the key. The class says what happened (ConnectError,
+        # ReadTimeout, ...), the base URL says where.
+        raise KeyInfoError(
+            f"Network error contacting {api_base}. Check your connection. ({type(exc).__name__})"
+        ) from exc
+
+    if response.status_code == 401:
+        raise KeyInfoError(
+            "Logify360 rejected this key (401). Re-copy it from the dashboard."
+        )
+    if response.status_code >= 400:
+        raise KeyInfoError(
+            f"Logify360 returned {response.status_code} from /me/key-info. Try again in a moment."
+        )
+
+    try:
+        payload = response.json()
+    except ValueError as exc:
+        raise KeyInfoError("Unexpected (non-JSON) response from /me/key-info.") from exc
+
+    data = payload.get("data") if isinstance(payload, dict) else None
+    if not isinstance(data, dict):
+        raise KeyInfoError("Unexpected response shape from /me/key-info.")
+
+    providers = data.get("providers") or []
+    if not isinstance(providers, list):
+        providers = []
+
+    return KeyInfo(
+        project_id=data.get("projectId"),
+        project_name=data.get("projectName"),
+        providers=[str(p) for p in providers],
+        scope=str(data.get("scope") or "full"),
+    )
+
+
+__all__ = ["KeyInfo", "KeyInfoError", "fetch_key_info"]