lushly-botcore 0.1.0__tar.gz

lushly_botcore-0.1.0/.gitignore

@@ -0,0 +1,28 @@
+# Dependencies
+node_modules/
+.venv/
+__pycache__/
+*.egg-info/
+
+# Build outputs
+dist/
+build/
+*.tsbuildinfo
+.turbo/
+
+# Test / coverage
+coverage/
+.pytest_cache/
+htmlcov/
+
+# IDE
+.idea/
+*.sw?
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Environment
+.env
+.env.local

lushly_botcore-0.1.0/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: lushly-botcore
+Version: 0.1.0
+Summary: Shared bot infrastructure — config, plugin contract, and extracted commands
+Author: Falkicon
+License: MIT
+Keywords: agent,botcore,cli,mcp,plugins
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.11
+Requires-Dist: afd>=0.1.0
+Requires-Dist: click>=8.1.0
+Requires-Dist: pydantic>=2.5.0
+Requires-Dist: pyyaml>=6.0.0
+Provides-Extra: all
+Requires-Dist: botcore[cdp,mcp,quality,research]; extra == 'all'
+Provides-Extra: cdp
+Requires-Dist: httpx>=0.24.0; extra == 'cdp'
+Requires-Dist: playwright>=1.40.0; extra == 'cdp'
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.4.0; extra == 'dev'
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.0.0; extra == 'mcp'
+Provides-Extra: quality
+Requires-Dist: httpx>=0.24.0; extra == 'quality'
+Provides-Extra: research
+Requires-Dist: google-genai>=0.3.0; extra == 'research'

lushly_botcore-0.1.0/pyproject.toml

@@ -0,0 +1,98 @@
+[project]
+name = "lushly-botcore"
+version = "0.1.0"
+description = "Shared bot infrastructure — config, plugin contract, and extracted commands"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [{ name = "Falkicon" }]
+keywords = ["botcore", "cli", "mcp", "plugins", "agent"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+dependencies = [
+    "afd>=0.1.0",
+    "pydantic>=2.5.0",
+    "click>=8.1.0",
+    "pyyaml>=6.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.23.0",
+    "pytest-cov>=4.0.0",
+    "ruff>=0.4.0",
+]
+cdp = [
+    "playwright>=1.40.0",
+    "httpx>=0.24.0",
+]
+research = [
+    "google-genai>=0.3.0",
+]
+quality = [
+    "httpx>=0.24.0",
+]
+mcp = [
+    "mcp>=1.0.0",
+]
+all = [
+    "botcore[cdp,research,quality,mcp]",
+]
+
+[project.entry-points."botcore.plugins"]
+# Plugins register here, e.g.:
+# lushbot = "lushbot_plugin:LushbotPlugin"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/botcore"]
+
+[tool.hatch.build]
+include = ["src/botcore/**/*.py", "src/botcore/skills/**/*.md"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+[tool.ruff.lint]
+select = [
+    "E", "F", "I", "UP",
+    "C901",
+    "PLR0912", "PLR0915", "PLR0913",
+]
+
+[tool.ruff.lint.mccabe]
+max-complexity = 20
+
+[tool.ruff.lint.pylint]
+max-args = 8
+max-branches = 20
+max-statements = 80
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+
+[tool.coverage.run]
+source = ["src/botcore"]
+branch = true
+omit = ["*/tests/*", "*/__pycache__/*"]
+
+[tool.coverage.report]
+show_missing = true
+exclude_lines = [
+    "pragma: no cover",
+    "if TYPE_CHECKING:",
+    "raise NotImplementedError",
+]

lushly_botcore-0.1.0/src/botcore/__init__.py

@@ -0,0 +1,46 @@
+"""Botcore — shared bot infrastructure for config, plugins, and commands."""
+
+from botcore.config import (
+    BotCoreConfig,
+    EnvConfig,
+    PackageOverrideConfig,
+    SkillsConfig,
+    get_config_for_path,
+    load_config,
+)
+from botcore.plugin import (
+    BotCorePlugin,
+    PluginRegistry,
+    discover_plugins,
+)
+from botcore.registry import (
+    get_client,
+    registry,
+    reset_client,
+)
+from botcore.server import build_docs, build_namespace, create_mcp_server
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "__version__",
+    # Config
+    "BotCoreConfig",
+    "SkillsConfig",
+    "PackageOverrideConfig",
+    "EnvConfig",
+    "load_config",
+    "get_config_for_path",
+    # Plugin
+    "PluginRegistry",
+    "BotCorePlugin",
+    "discover_plugins",
+    # Registry
+    "registry",
+    "get_client",
+    "reset_client",
+    # Server
+    "build_namespace",
+    "build_docs",
+    "create_mcp_server",
+]

lushly_botcore-0.1.0/src/botcore/commands/__init__.py

@@ -0,0 +1,70 @@
+"""Botcore command re-exports."""
+
+# Dev commands re-exported from subpackage
+from botcore.commands.dev import (
+    dev_build,
+    dev_check_coverage,
+    dev_check_deps,
+    dev_check_paths,
+    dev_check_size,
+    dev_circular_imports,
+    dev_dead_code,
+    dev_dep_graph,
+    dev_lint,
+    dev_skill_lint,
+    dev_test,
+    dev_unused_deps,
+)
+from botcore.commands.docs import docs_check_agents, docs_check_changelog, docs_lint
+from botcore.commands.info import info_env, info_scripts, info_workspace
+from botcore.commands.research import research_query
+from botcore.commands.skill import (
+    skill_adopt,
+    skill_index,
+    skill_lint,
+    skill_list,
+    skill_seed,
+    skill_status,
+)
+from botcore.commands.spec import spec_create, spec_status, spec_validate
+from botcore.commands.undo import undo_clear, undo_status
+
+__all__ = [
+    # Info
+    "info_workspace",
+    "info_env",
+    "info_scripts",
+    # Dev
+    "dev_lint",
+    "dev_test",
+    "dev_build",
+    "dev_skill_lint",
+    "dev_check_size",
+    "dev_check_coverage",
+    "dev_check_deps",
+    "dev_dead_code",
+    "dev_circular_imports",
+    "dev_unused_deps",
+    "dev_dep_graph",
+    "dev_check_paths",
+    # Skill registry
+    "skill_seed",
+    "skill_list",
+    "skill_status",
+    "skill_lint",
+    "skill_adopt",
+    "skill_index",
+    # Docs
+    "docs_lint",
+    "docs_check_changelog",
+    "docs_check_agents",
+    # Research
+    "research_query",
+    # Spec
+    "spec_create",
+    "spec_status",
+    "spec_validate",
+    # Undo
+    "undo_status",
+    "undo_clear",
+]

lushly_botcore-0.1.0/src/botcore/commands/cdp/__init__.py

@@ -0,0 +1,104 @@
+"""Botcore CDP commands — Chrome debug utilities.
+
+Modules:
+- core.py: Shared utilities, session management, constants
+- launcher.py: Browser launch, attach, close
+- navigation.py: Navigate, wait
+- interaction.py: Click, hover, scroll, drag, type, press
+- inspection.py: Inspect, query, snapshot
+- forms.py: Fill, upload, dialogs, page management
+- diagnostics.py: Screenshot, console, network, eval, emulate
+"""
+
+from botcore.commands.cdp.core import (
+    DEEP_QUERY_SINGLE_JS,
+    DEFAULT_TIMEOUT_MS,
+    CdpSession,
+    ConsoleEntry,
+)
+from botcore.commands.cdp.diagnostics import (
+    cdp_console,
+    cdp_emulate,
+    cdp_eval,
+    cdp_get_console_message,
+    cdp_get_network,
+    cdp_list_network,
+    cdp_screenshot,
+)
+from botcore.commands.cdp.forms import (
+    cdp_close_page,
+    cdp_fill,
+    cdp_fill_form,
+    cdp_handle_dialog,
+    cdp_list_pages,
+    cdp_new_page,
+    cdp_resize,
+    cdp_select_page,
+    cdp_upload,
+)
+from botcore.commands.cdp.inspection import (
+    cdp_inspect,
+    cdp_query,
+    cdp_snapshot,
+)
+from botcore.commands.cdp.interaction import (
+    cdp_click,
+    cdp_drag,
+    cdp_hover,
+    cdp_press,
+    cdp_scroll,
+    cdp_type,
+)
+from botcore.commands.cdp.launcher import (
+    cdp_attach,
+    cdp_close,
+    cdp_launch,
+)
+from botcore.commands.cdp.navigation import (
+    cdp_navigate,
+    cdp_wait,
+)
+
+__all__ = [
+    # Core
+    "CdpSession",
+    "ConsoleEntry",
+    "DEFAULT_TIMEOUT_MS",
+    "DEEP_QUERY_SINGLE_JS",
+    # Launcher
+    "cdp_launch",
+    "cdp_attach",
+    "cdp_close",
+    # Navigation
+    "cdp_navigate",
+    "cdp_wait",
+    # Interaction
+    "cdp_click",
+    "cdp_hover",
+    "cdp_scroll",
+    "cdp_drag",
+    "cdp_type",
+    "cdp_press",
+    # Inspection
+    "cdp_inspect",
+    "cdp_query",
+    "cdp_snapshot",
+    # Forms
+    "cdp_fill",
+    "cdp_fill_form",
+    "cdp_upload",
+    "cdp_handle_dialog",
+    "cdp_list_pages",
+    "cdp_select_page",
+    "cdp_new_page",
+    "cdp_close_page",
+    "cdp_resize",
+    # Diagnostics
+    "cdp_screenshot",
+    "cdp_console",
+    "cdp_get_console_message",
+    "cdp_eval",
+    "cdp_list_network",
+    "cdp_get_network",
+    "cdp_emulate",
+]

lushly_botcore-0.1.0/src/botcore/commands/cdp/core.py

@@ -0,0 +1,256 @@
+"""CDP core utilities — shared across all CDP modules."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import socket
+import subprocess
+from collections.abc import Awaitable, Callable
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any, TypeVar
+
+from afd import CommandResult, error, success
+from pydantic import BaseModel, Field
+
+from botcore.utils.workspace import find_workspace
+
+T = TypeVar("T")
+
+SESSION_DIRNAME = ".botcore"
+SESSION_FILENAME = "cdp-session.json"
+PROFILE_DIRNAME = "chrome-profile"
+SCREENSHOTS_DIRNAME = "screenshots"
+DEFAULT_TIMEOUT_MS = 30_000
+
+DEEP_QUERY_SINGLE_JS = """
+(selector) => {
+    function querySelectorDeep(root, sel) {
+        let result = root.querySelector(sel);
+        if (result) return result;
+        const elements = root.querySelectorAll('*');
+        for (const el of elements) {
+            if (el.shadowRoot) {
+                result = querySelectorDeep(el.shadowRoot, sel);
+                if (result) return result;
+            }
+        }
+        return null;
+    }
+    return querySelectorDeep(document, selector);
+}
+"""
+
+
+class ConsoleEntry(BaseModel):
+    """Captured console log entry."""
+
+    timestamp: str
+    level: str
+    text: str
+    url: str | None = None
+
+
+class CdpSession(BaseModel):
+    """CDP session metadata stored on disk."""
+
+    cdp_endpoint: str
+    profile_dir: str
+    launched_at: str
+    pid: int | None = None
+    console_log: list[ConsoleEntry] = Field(default_factory=list)
+
+
+def _now_iso() -> str:
+    return datetime.now(UTC).isoformat()
+
+
+def _session_root() -> Path:
+    return find_workspace() or Path.cwd()
+
+
+def _session_dir(root: Path) -> Path:
+    return root / SESSION_DIRNAME
+
+
+def _session_file(root: Path) -> Path:
+    return _session_dir(root) / SESSION_FILENAME
+
+
+def _ensure_session_dir(root: Path) -> Path:
+    session_dir = _session_dir(root)
+    session_dir.mkdir(parents=True, exist_ok=True)
+    return session_dir
+
+
+def _default_profile_dir(root: Path) -> Path:
+    root_drive = root.drive.rstrip("\\").lower()
+    localapp_drive = os.getenv("LOCALAPPDATA", "").split(":")[0].lower()
+    if root_drive and localapp_drive and root_drive != localapp_drive:
+        profile_root = Path(os.getenv("LOCALAPPDATA", "")) / "botcore"
+        profile_root.mkdir(parents=True, exist_ok=True)
+        return profile_root / PROFILE_DIRNAME
+    return _ensure_session_dir(root) / PROFILE_DIRNAME
+
+
+def _default_screenshots_dir(root: Path) -> Path:
+    return _ensure_session_dir(root) / SCREENSHOTS_DIRNAME
+
+
+def _load_session(root: Path) -> CdpSession | None:
+    session_path = _session_file(root)
+    if not session_path.exists():
+        return None
+    try:
+        data = json.loads(session_path.read_text(encoding="utf-8"))
+        return CdpSession(**data)
+    except Exception:
+        return None
+
+
+def _save_session(root: Path, session: CdpSession) -> None:
+    session_path = _session_file(root)
+    _ensure_session_dir(root)
+    session_path.write_text(session.model_dump_json(indent=2), encoding="utf-8")
+
+
+def _clear_session(root: Path) -> None:
+    session_path = _session_file(root)
+    if session_path.exists():
+        session_path.unlink()
+
+
+def _get_free_port() -> int:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.bind(("127.0.0.1", 0))
+        return sock.getsockname()[1]
+
+
+async def _probe_cdp(
+    endpoint: str,
+    timeout_s: float = 5.0,
+    attempts: int = 20,
+    delay_s: float = 0.5,
+) -> None:
+    """Probe CDP endpoint until it responds."""
+    import httpx
+
+    url = f"{endpoint.rstrip('/')}/json/version"
+    last_exc: Exception | None = None
+    for attempt in range(attempts):
+        try:
+            async with httpx.AsyncClient(timeout=timeout_s) as client:
+                response = await client.get(url)
+                response.raise_for_status()
+                return
+        except Exception as exc:
+            last_exc = exc
+            if attempt < attempts - 1:
+                await asyncio.sleep(delay_s)
+    if last_exc:
+        raise last_exc
+
+
+def _spawn_chrome(args: list[str]) -> subprocess.Popen[bytes]:
+    popen_kwargs: dict[str, Any] = {
+        "stdout": subprocess.DEVNULL,
+        "stderr": subprocess.DEVNULL,
+    }
+    if os.name == "nt":
+        popen_kwargs["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP
+    else:
+        popen_kwargs["start_new_session"] = True
+    return subprocess.Popen(args, **popen_kwargs)
+
+
+async def _get_chromium_executable() -> str:
+    from playwright.async_api import async_playwright
+
+    async with async_playwright() as playwright:
+        return playwright.chromium.executable_path
+
+
+async def _connect_over_cdp_with_retry(
+    playwright: Any,
+    endpoint: str,
+    attempts: int = 10,
+    delay_s: float = 0.3,
+) -> Any:
+    last_exc: Exception | None = None
+    for attempt in range(attempts):
+        try:
+            browser = await playwright.chromium.connect_over_cdp(endpoint)
+            return browser
+        except Exception as exc:
+            last_exc = exc
+            if attempt < attempts - 1:
+                await asyncio.sleep(delay_s)
+    if last_exc:
+        raise last_exc
+    raise RuntimeError("Failed to connect to CDP endpoint.")
+
+
+async def _with_session_page(
+    action: Callable[[Any], Awaitable[T]],
+    timeout_ms: int = DEFAULT_TIMEOUT_MS,
+) -> CommandResult[T]:
+    """Connect to active CDP session and run action on current page."""
+    from playwright.async_api import async_playwright
+
+    root = _session_root()
+    session = _load_session(root)
+    if not session:
+        return error(
+            "CDP_SESSION_NOT_FOUND",
+            "No active CDP session found.",
+            suggestion="Run `botcore cdp launch` or `botcore cdp attach` first.",
+        )
+
+    console_entries: list[ConsoleEntry] = []
+
+    def handle_console(msg: Any) -> None:
+        console_entries.append(
+            ConsoleEntry(
+                timestamp=_now_iso(),
+                level=msg.type,
+                text=msg.text,
+                url=msg.location.get("url") if msg.location else None,
+            )
+        )
+
+    try:
+        async with async_playwright() as playwright:
+            browser = await _connect_over_cdp_with_retry(playwright, session.cdp_endpoint)
+            context = browser.contexts[0] if browser.contexts else await browser.new_context()
+            page = context.pages[0] if context.pages else await context.new_page()
+            page.on("console", handle_console)
+            result = await action(page)
+            if console_entries:
+                session.console_log.extend(console_entries)
+                _save_session(root, session)
+            return success(data=result)
+    except Exception as exc:
+        import httpx
+
+        if isinstance(exc, httpx.HTTPError):
+            return error(
+                "CDP_CONNECT_FAILED",
+                f"Failed to reach CDP endpoint: {exc}",
+                suggestion="Ensure Chrome is running or run `botcore cdp launch`.",
+            )
+        exc_str = str(exc)
+        if "Timeout" in exc_str and "Locator" in exc_str:
+            suggestion = "Element not found. Use `botcore cdp query` to verify selector."
+        elif "Timeout" in exc_str:
+            suggestion = "Operation timed out. Check if page is responsive."
+        elif "Target closed" in exc_str or "Connection" in exc_str:
+            suggestion = "Browser disconnected. Run `botcore cdp launch` to start a new session."
+        else:
+            suggestion = "Check selector and page state. Use `botcore cdp screenshot` to debug."
+        return error(
+            "CDP_COMMAND_FAILED",
+            f"{type(exc).__name__}: {exc}",
+            suggestion=suggestion,
+        )