talocode-screenlane 0.1.0__tar.gz

talocode_screenlane-0.1.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: talocode-screenlane
+Version: 0.1.0
+Summary: Python SDK and CLI for ScreenLane — screen-aware voice command layer for AI agents
+Author: Talocode
+License: MIT
+Project-URL: Homepage, https://github.com/talocode/screenlane
+Project-URL: Repository, https://github.com/talocode/screenlane
+Keywords: screenlane,talocode,ai-agents,mcp,voice,screen-aware
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+
+# talocode-screenlane (Python)
+
+Python SDK and lightweight CLI for [ScreenLane](https://github.com/talocode/screenlane).
+
+The Node package owns OS capture, MCP, and the local API. This package is:
+
+- An HTTP client for `screenlane serve` (default `http://127.0.0.1:3070`)
+- Offline deterministic command helpers
+- CLI: `screenlane-py`
+
+## Install
+
+```bash
+pip install talocode-screenlane
+```
+
+## Usage
+
+```python
+from talocode_screenlane import ScreenLaneClient
+
+client = ScreenLaneClient(base_url="http://127.0.0.1:3070")
+# If SCREENLANE_REQUIRE_AUTH=true on the server:
+# client = ScreenLaneClient(api_key=os.environ["TALOCODE_API_KEY"])
+
+print(client.health())
+print(client.command({
+    "text": "Fix this error",
+    "contextText": "TypeError: ...",
+    "target": "codra",
+}))
+```
+
+CLI:
+
+```bash
+screenlane-py health
+screenlane-py command --text "Fix this error" --context-file error.txt
+screenlane-py command --text "Fix this error" --context-text "..." --offline
+screenlane-py demo
+```
+
+Auth uses **only** `TALOCODE_API_KEY` (Bearer header).
+
+## License
+
+MIT

talocode_screenlane-0.1.0/README.md

@@ -0,0 +1,47 @@
+# talocode-screenlane (Python)
+
+Python SDK and lightweight CLI for [ScreenLane](https://github.com/talocode/screenlane).
+
+The Node package owns OS capture, MCP, and the local API. This package is:
+
+- An HTTP client for `screenlane serve` (default `http://127.0.0.1:3070`)
+- Offline deterministic command helpers
+- CLI: `screenlane-py`
+
+## Install
+
+```bash
+pip install talocode-screenlane
+```
+
+## Usage
+
+```python
+from talocode_screenlane import ScreenLaneClient
+
+client = ScreenLaneClient(base_url="http://127.0.0.1:3070")
+# If SCREENLANE_REQUIRE_AUTH=true on the server:
+# client = ScreenLaneClient(api_key=os.environ["TALOCODE_API_KEY"])
+
+print(client.health())
+print(client.command({
+    "text": "Fix this error",
+    "contextText": "TypeError: ...",
+    "target": "codra",
+}))
+```
+
+CLI:
+
+```bash
+screenlane-py health
+screenlane-py command --text "Fix this error" --context-file error.txt
+screenlane-py command --text "Fix this error" --context-text "..." --offline
+screenlane-py demo
+```
+
+Auth uses **only** `TALOCODE_API_KEY` (Bearer header).
+
+## License
+
+MIT

talocode_screenlane-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "talocode-screenlane"
+version = "0.1.0"
+description = "Python SDK and CLI for ScreenLane — screen-aware voice command layer for AI agents"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Talocode" }]
+keywords = ["screenlane", "talocode", "ai-agents", "mcp", "voice", "screen-aware"]
+classifiers = [
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0", "build", "twine"]
+
+[project.scripts]
+screenlane-py = "talocode_screenlane.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/talocode/screenlane"
+Repository = "https://github.com/talocode/screenlane"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["talocode_screenlane*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

talocode_screenlane-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

talocode_screenlane-0.1.0/talocode_screenlane/__init__.py

@@ -0,0 +1,6 @@
+"""talocode-screenlane — Python client for ScreenLane."""
+
+from .client import ScreenLaneClient
+
+__version__ = "0.1.0"
+__all__ = ["ScreenLaneClient", "__version__"]

talocode_screenlane-0.1.0/talocode_screenlane/cli.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from . import __version__
+from .client import ScreenLaneClient, ScreenLaneError, build_local_command
+
+
+def _print(data: object) -> None:
+    if isinstance(data, str):
+        print(data)
+    else:
+        print(json.dumps(data, indent=2))
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="screenlane-py",
+        description="Python CLI for ScreenLane (HTTP client + offline helpers)",
+    )
+    parser.add_argument("--base-url", default="http://127.0.0.1:3070")
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    sub.add_parser("health", help="GET /v1/screenlane/health")
+    sub.add_parser("doctor", help="GET /v1/screenlane/doctor")
+    sub.add_parser("demo", help="POST /v1/screenlane/demo (or offline fallback)")
+
+    p_cmd = sub.add_parser("command", help="Build agent command via API or offline")
+    p_cmd.add_argument("--text", required=True)
+    p_cmd.add_argument("--context-file")
+    p_cmd.add_argument("--context-text", default="")
+    p_cmd.add_argument("--target", default="stdout")
+    p_cmd.add_argument("--offline", action="store_true", help="Do not call server")
+
+    p_cap = sub.add_parser("capture", help="POST capture")
+    p_cap.add_argument("--text")
+    p_cap.add_argument("--source", default="text")
+
+    args = parser.parse_args(argv)
+    client = ScreenLaneClient(base_url=args.base_url)
+
+    try:
+        if args.cmd == "health":
+            _print(client.health())
+            return 0
+        if args.cmd == "doctor":
+            _print(client.doctor())
+            return 0
+        if args.cmd == "demo":
+            try:
+                _print(client.demo())
+            except ScreenLaneError:
+                # offline deterministic demo
+                _print(
+                    build_local_command(
+                        "Fix this error",
+                        "TypeError: cannot read map of undefined at Dashboard.tsx:42",
+                        target="codra",
+                    )
+                )
+            return 0
+        if args.cmd == "command":
+            ctx = args.context_text or ""
+            if args.context_file:
+                ctx = Path(args.context_file).read_text(encoding="utf-8")
+            if args.offline:
+                _print(build_local_command(args.text, ctx, args.target))
+                return 0
+            try:
+                _print(
+                    client.command(
+                        {
+                            "text": args.text,
+                            "contextText": ctx,
+                            "target": args.target,
+                            "save": False,
+                        }
+                    )
+                )
+            except ScreenLaneError:
+                _print(build_local_command(args.text, ctx, args.target))
+            return 0
+        if args.cmd == "capture":
+            _print(client.capture({"source": args.source, "text": args.text, "save": False}))
+            return 0
+    except ScreenLaneError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

talocode_screenlane-0.1.0/talocode_screenlane/client.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import json
+import os
+import urllib.error
+import urllib.request
+from typing import Any, Optional
+
+
+class ScreenLaneError(Exception):
+    def __init__(self, message: str, status: Optional[int] = None):
+        super().__init__(message)
+        self.status = status
+
+
+class ScreenLaneClient:
+    """HTTP client for a local ScreenLane server + local helpers."""
+
+    def __init__(
+        self,
+        base_url: str = "http://127.0.0.1:3070",
+        api_key: Optional[str] = None,
+        timeout: float = 30.0,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key or os.environ.get("TALOCODE_API_KEY")
+        self.timeout = timeout
+
+    def _request(self, method: str, path: str, body: Any = None) -> Any:
+        url = f"{self.base_url}{path}"
+        data = None if body is None else json.dumps(body).encode("utf-8")
+        headers = {"Accept": "application/json", "Content-Type": "application/json"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+            headers["X-Talocode-Api-Key"] = self.api_key
+        req = urllib.request.Request(url, data=data, headers=headers, method=method)
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                raw = resp.read().decode("utf-8")
+                return json.loads(raw) if raw else {}
+        except urllib.error.HTTPError as e:
+            detail = e.read().decode("utf-8", errors="replace")
+            raise ScreenLaneError(f"HTTP {e.code}: {detail[:300]}", status=e.code) from e
+        except urllib.error.URLError as e:
+            raise ScreenLaneError(
+                f"Cannot reach ScreenLane at {self.base_url}: {e.reason}. "
+                "Start the server with `screenlane serve`."
+            ) from e
+
+    def health(self) -> Any:
+        return self._request("GET", "/v1/screenlane/health")
+
+    def doctor(self) -> Any:
+        return self._request("GET", "/v1/screenlane/doctor")
+
+    def capture(self, payload: Optional[dict] = None) -> Any:
+        return self._request("POST", "/v1/screenlane/capture", payload or {})
+
+    def dictate(self, payload: Optional[dict] = None) -> Any:
+        return self._request("POST", "/v1/screenlane/dictate", payload or {})
+
+    def command(self, payload: Optional[dict] = None) -> Any:
+        return self._request("POST", "/v1/screenlane/command", payload or {})
+
+    def send(self, payload: Optional[dict] = None) -> Any:
+        return self._request("POST", "/v1/screenlane/send", payload or {})
+
+    def list_contexts(self) -> Any:
+        return self._request("GET", "/v1/screenlane/contexts")
+
+    def list_commands(self) -> Any:
+        return self._request("GET", "/v1/screenlane/commands")
+
+    def demo(self) -> Any:
+        return self._request("POST", "/v1/screenlane/demo", {})
+
+
+def build_local_command(
+    instruction: str,
+    context_text: str = "",
+    target: str = "stdout",
+) -> dict:
+    """Deterministic offline helper (no server required)."""
+    intent = "general_action"
+    lower = f"{instruction}\n{context_text}".lower()
+    if any(k in lower for k in ("fix", "error", "debug", "exception")):
+        intent = "debug_error"
+    elif any(k in lower for k in ("explain", "summarize")):
+        intent = "explain"
+    elif "reply" in lower or "email" in lower:
+        intent = "write_reply"
+    prompt = (
+        f"Target: {target}\nIntent: {intent}\n\n"
+        f"Screen context:\n```\n{context_text[:4000]}\n```\n\n"
+        f"User instruction:\n{instruction}\n\n"
+        "Act on the instruction using the context. Prefer minimal, safe changes."
+    )
+    return {
+        "intent": intent,
+        "instruction": instruction,
+        "target": target,
+        "prompt": prompt,
+        "offline": True,
+    }

talocode_screenlane-0.1.0/talocode_screenlane.egg-info/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: talocode-screenlane
+Version: 0.1.0
+Summary: Python SDK and CLI for ScreenLane — screen-aware voice command layer for AI agents
+Author: Talocode
+License: MIT
+Project-URL: Homepage, https://github.com/talocode/screenlane
+Project-URL: Repository, https://github.com/talocode/screenlane
+Keywords: screenlane,talocode,ai-agents,mcp,voice,screen-aware
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+
+# talocode-screenlane (Python)
+
+Python SDK and lightweight CLI for [ScreenLane](https://github.com/talocode/screenlane).
+
+The Node package owns OS capture, MCP, and the local API. This package is:
+
+- An HTTP client for `screenlane serve` (default `http://127.0.0.1:3070`)
+- Offline deterministic command helpers
+- CLI: `screenlane-py`
+
+## Install
+
+```bash
+pip install talocode-screenlane
+```
+
+## Usage
+
+```python
+from talocode_screenlane import ScreenLaneClient
+
+client = ScreenLaneClient(base_url="http://127.0.0.1:3070")
+# If SCREENLANE_REQUIRE_AUTH=true on the server:
+# client = ScreenLaneClient(api_key=os.environ["TALOCODE_API_KEY"])
+
+print(client.health())
+print(client.command({
+    "text": "Fix this error",
+    "contextText": "TypeError: ...",
+    "target": "codra",
+}))
+```
+
+CLI:
+
+```bash
+screenlane-py health
+screenlane-py command --text "Fix this error" --context-file error.txt
+screenlane-py command --text "Fix this error" --context-text "..." --offline
+screenlane-py demo
+```
+
+Auth uses **only** `TALOCODE_API_KEY` (Bearer header).
+
+## License
+
+MIT

talocode_screenlane-0.1.0/talocode_screenlane.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+talocode_screenlane/__init__.py
+talocode_screenlane/cli.py
+talocode_screenlane/client.py
+talocode_screenlane.egg-info/PKG-INFO
+talocode_screenlane.egg-info/SOURCES.txt
+talocode_screenlane.egg-info/dependency_links.txt
+talocode_screenlane.egg-info/entry_points.txt
+talocode_screenlane.egg-info/requires.txt
+talocode_screenlane.egg-info/top_level.txt
+tests/test_client.py

talocode_screenlane-0.1.0/talocode_screenlane.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

talocode_screenlane-0.1.0/talocode_screenlane.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+screenlane-py = talocode_screenlane.cli:main

talocode_screenlane-0.1.0/talocode_screenlane.egg-info/requires.txt

@@ -0,0 +1,5 @@
+
+[dev]
+pytest>=7.0
+build
+twine

talocode_screenlane-0.1.0/talocode_screenlane.egg-info/top_level.txt

@@ -0,0 +1 @@
+talocode_screenlane

talocode_screenlane-0.1.0/tests/test_client.py

@@ -0,0 +1,22 @@
+from talocode_screenlane.client import build_local_command
+from talocode_screenlane import __version__
+
+
+def test_version():
+    assert __version__ == "0.1.0"
+
+
+def test_build_local_command_debug():
+    cmd = build_local_command(
+        "Fix this error",
+        "TypeError: boom at app.ts:1",
+        target="codra",
+    )
+    assert cmd["intent"] == "debug_error"
+    assert "Fix this error" in cmd["prompt"]
+    assert cmd["offline"] is True
+
+
+def test_build_local_command_explain():
+    cmd = build_local_command("Explain this page", "Hello docs", target="stdout")
+    assert cmd["intent"] == "explain"