aicortexpy 0.1.0__py3-none-any.whl

aicortexpy/health.py

@@ -0,0 +1,178 @@
+"""Local health HTTP endpoint (single-instance lock via bind)."""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import threading
+import time
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from typing import Any, Callable
+
+log = logging.getLogger("aicortexpy.health")
+
+
+class HealthServer:
+    def __init__(
+        self,
+        port: int,
+        snapshot: Callable[[], dict[str, Any]],
+        *,
+        workspaces_root: Path | None = None,
+        on_shutdown: Callable[[], None] | None = None,
+        repo_allowlist: Any = None,
+        client: Any = None,
+    ):
+        self.port = port
+        self.snapshot = snapshot
+        self.workspaces_root = workspaces_root
+        self.on_shutdown = on_shutdown
+        self.repo_allowlist = repo_allowlist
+        self.client = client
+        self._httpd: ThreadingHTTPServer | None = None
+        self._thread: threading.Thread | None = None
+        self.started_at = time.time()
+
+    def start(self) -> None:
+        snapshot = self.snapshot
+        started_at = self.started_at
+        workspaces_root = self.workspaces_root
+        on_shutdown = self.on_shutdown
+        repo_allowlist = self.repo_allowlist
+        client = self.client
+
+        class Handler(BaseHTTPRequestHandler):
+            def do_GET(self):  # noqa: N802
+                if self.path.split("?")[0] not in ("/health", "/"):
+                    self.send_response(404)
+                    self.end_headers()
+                    return
+                body = snapshot()
+                body.setdefault("status", "running")
+                body.setdefault("pid", os.getpid())
+                body.setdefault("uptime", f"{int(time.time() - started_at)}s")
+                raw = json.dumps(body).encode("utf-8")
+                self.send_response(200)
+                self.send_header("Content-Type", "application/json")
+                self.send_header("Content-Length", str(len(raw)))
+                self.end_headers()
+                self.wfile.write(raw)
+
+            def do_POST(self):  # noqa: N802
+                path = self.path.split("?")[0]
+                if path == "/shutdown":
+                    self.send_response(200)
+                    self.send_header("Content-Type", "application/json")
+                    self.end_headers()
+                    self.wfile.write(b'{"ok":true}')
+                    if on_shutdown:
+                        threading.Thread(target=on_shutdown, daemon=True).start()
+                    threading.Thread(target=self.server.shutdown, daemon=True).start()
+                    return
+                if path == "/repo/checkout":
+                    self._repo_checkout()
+                    return
+                self.send_response(404)
+                self.end_headers()
+
+            def _repo_checkout(self) -> None:
+                length = int(self.headers.get("Content-Length") or 0)
+                raw_body = self.rfile.read(length) if length else b"{}"
+                try:
+                    req = json.loads(raw_body.decode("utf-8"))
+                except json.JSONDecodeError:
+                    self.send_error(400, "invalid json")
+                    return
+                url = str(req.get("url") or "")
+                workspace_id = str(req.get("workspace_id") or "")
+                workdir = str(req.get("workdir") or "")
+                ref = str(req.get("ref") or "")
+                agent_name = str(req.get("agent_name") or req.get("agentName") or "agent")
+                task_id = str(req.get("task_id") or req.get("taskId") or "")
+                co = req.get("co_authored_by_enabled")
+                if co is None:
+                    co = req.get("coAuthoredByEnabled")
+                co_authored_by = True if co is None else bool(co)
+                if not url or not workspace_id or not workdir:
+                    self.send_error(400, "url, workspace_id, workdir required")
+                    return
+                if workspaces_root is None:
+                    self.send_error(500, "repo cache not initialized")
+                    return
+                from .repo import checkout_api
+
+                result = checkout_api(
+                    workspaces_root,
+                    url=url,
+                    workspace_id=workspace_id,
+                    workdir=workdir,
+                    ref=ref,
+                    allowlist=repo_allowlist,
+                    client=client,
+                    agent_name=agent_name,
+                    task_id=task_id,
+                    co_authored_by=co_authored_by,
+                )
+                raw = json.dumps(result).encode("utf-8")
+                if result.get("ok"):
+                    code = 200
+                elif int(result.get("status") or 0) == 400:
+                    code = 400
+                else:
+                    code = 500
+                self.send_response(code)
+                self.send_header("Content-Type", "application/json")
+                self.send_header("Content-Length", str(len(raw)))
+                self.end_headers()
+                self.wfile.write(raw)
+
+            def log_message(self, fmt: str, *args: Any) -> None:
+                log.debug("health: " + fmt, *args)
+
+        try:
+            httpd = ThreadingHTTPServer(("127.0.0.1", self.port), Handler)
+        except OSError as e:
+            raise RuntimeError(
+                f"another daemon is already running on 127.0.0.1:{self.port}: {e}"
+            ) from e
+        self._httpd = httpd
+        t = threading.Thread(target=httpd.serve_forever, name="health", daemon=True)
+        t.start()
+        self._thread = t
+        log.info("health listening on 127.0.0.1:%s", self.port)
+
+    def stop(self) -> None:
+        if self._httpd:
+            self._httpd.shutdown()
+            self._httpd.server_close()
+            self._httpd = None
+
+
+def fetch_health(port: int, timeout: float = 2.0) -> dict[str, Any] | None:
+    import urllib.request
+
+    try:
+        with urllib.request.urlopen(
+            f"http://127.0.0.1:{port}/health", timeout=timeout
+        ) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+    except Exception:
+        return None
+
+
+def request_shutdown(port: int, timeout: float = 5.0) -> bool:
+    import urllib.request
+
+    try:
+        req = urllib.request.Request(
+            f"http://127.0.0.1:{port}/shutdown",
+            data=b"{}",
+            method="POST",
+            headers={"Content-Type": "application/json"},
+        )
+        with urllib.request.urlopen(req, timeout=timeout):
+            return True
+    except Exception:
+        return False

aicortexpy/local_skills.py

@@ -0,0 +1,157 @@
+"""Scan / import runtime-local skills (aligned with Go local_skills.go)."""
+
+from __future__ import annotations
+
+import logging
+import os
+from pathlib import Path
+from typing import Any
+
+log = logging.getLogger("aicortexpy.local_skills")
+
+MAX_FILE_SIZE = 1 << 20
+MAX_BUNDLE_SIZE = 8 << 20
+MAX_FILE_COUNT = 128
+MAX_DEPTH = 4
+
+
+def skill_root_for_provider(provider: str) -> tuple[Path | None, bool]:
+    home = Path.home()
+    if provider in ("claude", "cursor", "kiro"):
+        mapping = {
+            "claude": home / ".claude" / "skills",
+            "cursor": home / ".cursor" / "skills",
+            "kiro": home / ".kiro" / "skills",
+        }
+        return mapping[provider], True
+    if provider == "codex":
+        codex_home = os.environ.get("CODEX_HOME", "").strip()
+        root = Path(codex_home) if codex_home else home / ".codex"
+        return root / "skills", True
+    if provider == "copilot":
+        return home / ".copilot" / "skills", True
+    if provider == "opencode":
+        return home / ".config" / "opencode" / "skills", True
+    if provider == "openclaw":
+        return home / ".openclaw" / "skills", True
+    if provider == "pi":
+        return home / ".pi" / "agent" / "skills", True
+    return None, False
+
+
+def list_runtime_local_skills(provider: str) -> tuple[list[dict[str, Any]], bool]:
+    root, supported = skill_root_for_provider(provider)
+    if not supported or root is None:
+        return [], False
+    if not root.is_dir():
+        return [], True
+    skills: list[dict[str, Any]] = []
+    for skill_md in _find_skill_mds(root, max_depth=MAX_DEPTH):
+        skill_dir = skill_md.parent
+        rel = skill_dir.relative_to(root).as_posix()
+        name = skill_dir.name
+        desc = _read_description(skill_md)
+        files = list(skill_dir.rglob("*"))
+        file_count = sum(1 for f in files if f.is_file())
+        skills.append(
+            {
+                "key": rel,
+                "name": name,
+                "description": desc,
+                "source_path": str(skill_dir),
+                "provider": provider,
+                "file_count": file_count,
+            }
+        )
+    skills.sort(key=lambda s: s["key"])
+    return skills, True
+
+
+def load_runtime_local_skill_bundle(
+    provider: str, skill_key: str
+) -> tuple[dict[str, Any] | None, bool, str]:
+    root, supported = skill_root_for_provider(provider)
+    if not supported or root is None:
+        return None, False, "provider does not support local skills"
+    skill_dir = (root / skill_key).resolve()
+    try:
+        skill_dir.relative_to(root.resolve())
+    except ValueError:
+        return None, True, "skill key escapes skills root"
+    skill_md = skill_dir / "SKILL.md"
+    if not skill_md.is_file():
+        return None, True, "SKILL.md not found"
+    content = skill_md.read_text(encoding="utf-8", errors="replace")
+    files: list[dict[str, str]] = []
+    total = len(content.encode("utf-8"))
+    count = 0
+    for path in skill_dir.rglob("*"):
+        if not path.is_file() or path.name == "SKILL.md":
+            continue
+        count += 1
+        if count > MAX_FILE_COUNT:
+            break
+        try:
+            size = path.stat().st_size
+        except OSError:
+            continue
+        if size > MAX_FILE_SIZE:
+            continue
+        total += size
+        if total > MAX_BUNDLE_SIZE:
+            break
+        rel = path.relative_to(skill_dir).as_posix()
+        try:
+            text = path.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            continue
+        files.append({"path": rel, "content": text})
+    return (
+        {
+            "name": skill_dir.name,
+            "description": _read_description(skill_md),
+            "content": content,
+            "source_path": str(skill_dir),
+            "provider": provider,
+            "files": files,
+        },
+        True,
+        "",
+    )
+
+
+def _find_skill_mds(root: Path, max_depth: int) -> list[Path]:
+    found: list[Path] = []
+    root_depth = len(root.parts)
+
+    def walk(d: Path) -> None:
+        if len(d.parts) - root_depth > max_depth:
+            return
+        skill = d / "SKILL.md"
+        if skill.is_file():
+            found.append(skill)
+            return
+        try:
+            children = list(d.iterdir())
+        except OSError:
+            return
+        for c in children:
+            if c.is_dir() and not c.name.startswith("."):
+                walk(c)
+
+    walk(root)
+    return found
+
+
+def _read_description(skill_md: Path) -> str:
+    try:
+        text = skill_md.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return ""
+    for line in text.splitlines():
+        line = line.strip()
+        if line.startswith("#"):
+            continue
+        if line:
+            return line[:240]
+    return ""