aicortexpy 0.1.0__py3-none-any.whl

aicortexpy/__init__.py

@@ -0,0 +1,3 @@
+"""AICortex Python local agent runtime daemon."""
+
+__version__ = "0.1.0"

aicortexpy/__main__.py

@@ -0,0 +1,5 @@
+"""Allow `python -m aicortexpy` invocation."""
+
+from .cli import main
+
+raise SystemExit(main())

aicortexpy/acp_client.py

@@ -0,0 +1,559 @@
+"""ACP JSON-RPC 2.0 client over newline-delimited stdin/stdout.
+
+Port of the shared hermesClient used by Cursor/Kiro/Hermes ACP backends.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+import threading
+from dataclasses import dataclass, field
+from typing import Any, Callable, TextIO
+
+log = logging.getLogger("aicortexpy.acp")
+
+MessageCB = Callable[[dict[str, Any]], None]
+PromptDoneCB = Callable[["PromptResult"], None]
+AcceptCB = Callable[[str], bool]
+
+
+@dataclass
+class TokenUsage:
+    input_tokens: int = 0
+    output_tokens: int = 0
+    cache_read_tokens: int = 0
+
+
+@dataclass
+class PromptResult:
+    stop_reason: str = ""
+    usage: TokenUsage = field(default_factory=TokenUsage)
+
+
+@dataclass
+class _PendingRPC:
+    event: threading.Event
+    method: str
+    result: Any = None
+    error: Exception | None = None
+
+
+@dataclass
+class _PendingTool:
+    tool_name: str = ""
+    input: dict[str, Any] | None = None
+    args_text: str = ""
+    emitted: bool = False
+
+
+class ACPClient:
+    """Thread-safe JSON-RPC client for one ACP child process."""
+
+    def __init__(self, stdin: TextIO, *, tool_name_fn: Callable[[str, str], str] | None = None) -> None:
+        self._stdin = stdin
+        self._write_lock = threading.Lock()
+        self._mu = threading.Lock()
+        self._next_id = 1
+        self._pending: dict[int, _PendingRPC] = {}
+        self._tool_mu = threading.Lock()
+        self._pending_tools: dict[str, _PendingTool] = {}
+        self.tool_name_fn = tool_name_fn or default_tool_name
+        self.session_id = ""
+        self.on_message: MessageCB | None = None
+        self.on_prompt_done: PromptDoneCB | None = None
+        self.accept_notification: AcceptCB | None = None
+        self.usage = TokenUsage()
+        self._usage_lock = threading.Lock()
+
+    def write_line(self, data: bytes) -> None:
+        with self._write_lock:
+            self._stdin.buffer.write(data)
+            self._stdin.buffer.flush()
+
+    def request(self, method: str, params: Any, *, timeout: float) -> Any:
+        with self._mu:
+            req_id = self._next_id
+            self._next_id += 1
+            pending = _PendingRPC(event=threading.Event(), method=method)
+            self._pending[req_id] = pending
+        payload = {"jsonrpc": "2.0", "id": req_id, "method": method, "params": params}
+        raw = (json.dumps(payload, ensure_ascii=False) + "\n").encode("utf-8")
+        try:
+            self.write_line(raw)
+        except OSError as e:
+            with self._mu:
+                self._pending.pop(req_id, None)
+            raise RuntimeError(f"write {method}: {e}") from e
+        if not pending.event.wait(timeout):
+            with self._mu:
+                self._pending.pop(req_id, None)
+            raise TimeoutError(f"{method} timed out after {timeout:.0f}s")
+        if pending.error:
+            raise pending.error
+        return pending.result
+
+    def close_all_pending(self, err: Exception) -> None:
+        with self._mu:
+            items = list(self._pending.items())
+            self._pending.clear()
+        for _, pr in items:
+            pr.error = err
+            pr.event.set()
+
+    def handle_line(self, line: str) -> None:
+        line = line.strip()
+        if not line:
+            return
+        try:
+            raw = json.loads(line)
+        except json.JSONDecodeError:
+            return
+        if not isinstance(raw, dict):
+            return
+        if "id" in raw:
+            if "result" in raw or "error" in raw:
+                self._handle_response(raw)
+                return
+            if "method" in raw:
+                self._handle_agent_request(raw)
+                return
+        if "method" in raw:
+            self._handle_notification(raw)
+
+    def _handle_response(self, raw: dict[str, Any]) -> None:
+        rid = raw.get("id")
+        try:
+            req_id = int(rid)
+        except (TypeError, ValueError):
+            return
+        with self._mu:
+            pr = self._pending.pop(req_id, None)
+        if pr is None:
+            return
+        if "error" in raw:
+            err = raw["error"] if isinstance(raw["error"], dict) else {}
+            msg = str(err.get("message") or "rpc error")
+            code = err.get("code")
+            data = err.get("data")
+            detail = ""
+            if data is not None and data != "null":
+                detail = data if isinstance(data, str) else json.dumps(data, ensure_ascii=False)
+            text = f"{pr.method}: {msg} (code={code})"
+            if detail:
+                text += f", data={detail}"
+            pr.error = RuntimeError(text)
+        else:
+            result = raw.get("result")
+            if pr.method == "session/prompt":
+                self._extract_prompt_result(result)
+            pr.result = result
+        pr.event.set()
+
+    def _handle_agent_request(self, raw: dict[str, Any]) -> None:
+        method = str(raw.get("method") or "")
+        req_id = raw.get("id")
+        if method == "session/request_permission":
+            option_id = _select_permission_option_id(raw.get("params"))
+            result = {"outcome": {"outcome": "selected", "optionId": option_id}}
+            log.debug("auto-approved permission option_id=%s", option_id)
+        elif method == "cursor/ask_question":
+            result = {
+                "outcome": {
+                    "outcome": "skipped",
+                    "reason": "headless daemon — no interactive UI",
+                }
+            }
+        elif method == "cursor/create_plan":
+            result = {"outcome": {"outcome": "accepted"}}
+        elif method == "cursor/task":
+            result = {
+                "outcome": {
+                    "outcome": "rejected",
+                    "reason": (
+                        "headless daemon — subagent delegation unavailable; "
+                        "use main session tools"
+                    ),
+                }
+            }
+        else:
+            resp = {
+                "jsonrpc": "2.0",
+                "id": req_id,
+                "error": {"code": -32601, "message": f"method not found: {method}"},
+            }
+            try:
+                self.write_line((json.dumps(resp) + "\n").encode("utf-8"))
+            except OSError:
+                pass
+            return
+        resp = {"jsonrpc": "2.0", "id": req_id, "result": result}
+        try:
+            self.write_line((json.dumps(resp, ensure_ascii=False) + "\n").encode("utf-8"))
+        except OSError as e:
+            log.warning("write agent-request response failed: %s", e)
+
+    def _handle_notification(self, raw: dict[str, Any]) -> None:
+        method = str(raw.get("method") or "")
+        if method not in ("session/update", "session/notification"):
+            return
+        params = raw.get("params") if isinstance(raw.get("params"), dict) else {}
+        update = params.get("update")
+        if update is None:
+            return
+        update_type, update_data = _normalize_update(update)
+        if self.accept_notification and not self.accept_notification(update_type):
+            return
+        if update_type == "agent_message_chunk":
+            text = _content_text(update_data)
+            if text and self.on_message:
+                self.on_message({"type": "text", "content": text})
+        elif update_type == "agent_thought_chunk":
+            text = _content_text(update_data)
+            if text and self.on_message:
+                self.on_message({"type": "thinking", "content": text})
+        elif update_type == "tool_call":
+            self._handle_tool_call_start(update_data)
+        elif update_type == "tool_call_update":
+            self._handle_tool_call_update(update_data)
+        elif update_type == "usage_update":
+            self._handle_usage_update(update_data)
+        elif update_type == "turn_end":
+            self._extract_prompt_result(update_data)
+
+    def _handle_tool_call_start(self, data: Any) -> None:
+        if not isinstance(data, dict):
+            return
+        call_id = str(data.get("toolCallId") or "")
+        title = str(data.get("title") or "")
+        kind = str(data.get("kind") or "")
+        name = str(data.get("name") or "")
+        tool_name = self.tool_name_fn(title, kind) or name
+        raw_input = data.get("rawInput") or data.get("input") or data.get("parameters")
+        if isinstance(raw_input, dict):
+            self._track_tool(call_id, _PendingTool(tool_name=tool_name, input=raw_input, emitted=True))
+            if self.on_message:
+                self.on_message(
+                    {
+                        "type": "tool-use",
+                        "tool": tool_name,
+                        "call_id": call_id,
+                        "input": raw_input,
+                    }
+                )
+            return
+        content = data.get("content") if isinstance(data.get("content"), list) else []
+        self._track_tool(
+            call_id,
+            _PendingTool(
+                tool_name=tool_name,
+                args_text=_extract_tool_call_text(content),
+                emitted=False,
+            ),
+        )
+
+    def _handle_tool_call_update(self, data: Any) -> None:
+        if not isinstance(data, dict):
+            return
+        call_id = str(data.get("toolCallId") or "")
+        status = str(data.get("status") or "")
+        content = data.get("content") if isinstance(data.get("content"), list) else []
+        if status not in ("completed", "failed"):
+            pending = self._get_pending_tool(call_id)
+            if pending is not None and not pending.emitted:
+                text = _extract_tool_call_text(content)
+                if text:
+                    pending.args_text = text
+            return
+        pending = self._take_pending_tool(call_id)
+        self._emit_deferred_tool_use(pending, call_id, data)
+        output = str(data.get("rawOutput") or data.get("output") or "")
+        if not output:
+            output = _extract_tool_call_text(content)
+        if self.on_message:
+            self.on_message({"type": "tool-result", "call_id": call_id, "output": output})
+
+    def _emit_deferred_tool_use(self, pending: _PendingTool | None, call_id: str, data: dict) -> None:
+        if pending is not None and pending.emitted:
+            return
+        title = str(data.get("title") or data.get("name") or "")
+        kind = str(data.get("kind") or "")
+        raw_input = data.get("rawInput") or data.get("input") or data.get("parameters")
+        tool_name = ""
+        inp: dict[str, Any] | None = None
+        if pending is not None:
+            tool_name = pending.tool_name
+            if pending.input is not None:
+                inp = pending.input
+            elif pending.args_text:
+                try:
+                    parsed = json.loads(pending.args_text)
+                    inp = parsed if isinstance(parsed, dict) else {"text": pending.args_text}
+                except json.JSONDecodeError:
+                    inp = {"text": pending.args_text}
+        if not tool_name:
+            tool_name = self.tool_name_fn(title, kind) or str(data.get("name") or "tool")
+        if inp is None and isinstance(raw_input, dict):
+            inp = raw_input
+        if inp is None:
+            inp = {}
+        if self.on_message:
+            self.on_message(
+                {"type": "tool-use", "tool": tool_name, "call_id": call_id, "input": inp}
+            )
+
+    def _track_tool(self, call_id: str, p: _PendingTool) -> None:
+        if not call_id:
+            return
+        with self._tool_mu:
+            self._pending_tools[call_id] = p
+
+    def _get_pending_tool(self, call_id: str) -> _PendingTool | None:
+        with self._tool_mu:
+            return self._pending_tools.get(call_id)
+
+    def _take_pending_tool(self, call_id: str) -> _PendingTool | None:
+        with self._tool_mu:
+            return self._pending_tools.pop(call_id, None)
+
+    def _extract_prompt_result(self, data: Any) -> None:
+        if not isinstance(data, dict):
+            return
+        pr = PromptResult(stop_reason=str(data.get("stopReason") or ""))
+        usage = data.get("usage")
+        if isinstance(usage, dict):
+            pr.usage = TokenUsage(
+                input_tokens=int(usage.get("inputTokens") or 0),
+                output_tokens=int(usage.get("outputTokens") or 0),
+                cache_read_tokens=int(usage.get("cachedReadTokens") or 0),
+            )
+        if self.on_prompt_done:
+            self.on_prompt_done(pr)
+
+    def _handle_usage_update(self, data: Any) -> None:
+        if not isinstance(data, dict):
+            return
+        usage = data.get("usage") if isinstance(data.get("usage"), dict) else data
+        if not isinstance(usage, dict):
+            return
+        with self._usage_lock:
+            self.usage.input_tokens = int(
+                usage.get("inputTokens") or usage.get("input_tokens") or self.usage.input_tokens
+            )
+            self.usage.output_tokens = int(
+                usage.get("outputTokens") or usage.get("output_tokens") or self.usage.output_tokens
+            )
+            self.usage.cache_read_tokens = int(
+                usage.get("cachedReadTokens")
+                or usage.get("cache_read_tokens")
+                or self.usage.cache_read_tokens
+            )
+
+
+def extract_session_id(result: Any) -> str:
+    if not isinstance(result, dict):
+        return ""
+    for key in ("sessionId", "session_id", "id"):
+        v = result.get(key)
+        if isinstance(v, str) and v.strip():
+            return v.strip()
+    session = result.get("session")
+    if isinstance(session, dict):
+        return extract_session_id(session)
+    return ""
+
+
+def resolve_resumed_session_id(requested: str, response: Any) -> tuple[str, bool]:
+    actual = extract_session_id(response) or requested
+    return actual, bool(actual and requested and actual != requested)
+
+
+def _select_permission_option_id(params: Any) -> str:
+    fallback = "approve_for_session"
+    if not isinstance(params, dict):
+        return fallback
+    options = params.get("options")
+    if not isinstance(options, list) or not options:
+        return fallback
+    prefer = ("allow-always", "approve_for_session", "allow-once", "approve")
+    by_id = {
+        str(o.get("optionId") or ""): o
+        for o in options
+        if isinstance(o, dict)
+    }
+    for want in prefer:
+        if want in by_id:
+            return want
+    for o in options:
+        if isinstance(o, dict) and o.get("kind") == "allow_always":
+            return str(o.get("optionId") or fallback)
+    for o in options:
+        if isinstance(o, dict) and o.get("kind") == "allow_once":
+            return str(o.get("optionId") or fallback)
+    first = options[0]
+    if isinstance(first, dict):
+        return str(first.get("optionId") or fallback)
+    return fallback
+
+
+def _normalize_update(data: Any) -> tuple[str, Any]:
+    if not isinstance(data, dict):
+        return "", data
+    session_update = str(data.get("sessionUpdate") or "")
+    typ = str(data.get("type") or "")
+    if session_update:
+        return _normalize_type(session_update), data
+    if typ:
+        return _normalize_type(typ), data
+    if len(data) == 1:
+        k, v = next(iter(data.items()))
+        return _normalize_type(str(k)), v
+    return "", data
+
+
+def _normalize_type(t: str) -> str:
+    key = re.sub(r"[\s_\-]", "", t.strip().lower())
+    mapping = {
+        "agentmessagechunk": "agent_message_chunk",
+        "agentthoughtchunk": "agent_thought_chunk",
+        "toolcall": "tool_call",
+        "toolcallupdate": "tool_call_update",
+        "usageupdate": "usage_update",
+        "turnend": "turn_end",
+        "endturn": "turn_end",
+    }
+    return mapping.get(key, "")
+
+
+def _content_text(data: Any) -> str:
+    if not isinstance(data, dict):
+        return ""
+    content = data.get("content")
+    if isinstance(content, dict):
+        return str(content.get("text") or "")
+    return str(data.get("text") or "")
+
+
+def _extract_tool_call_text(blocks: Any) -> str:
+    if not isinstance(blocks, list):
+        return ""
+    parts: list[str] = []
+    for raw in blocks:
+        if not isinstance(raw, dict):
+            continue
+        typ = str(raw.get("type") or "")
+        if typ == "content":
+            inner = raw.get("content")
+            if isinstance(inner, dict) and str(inner.get("type") or "") == "text":
+                text = str(inner.get("text") or "")
+                if text:
+                    parts.append(text)
+        elif typ == "diff":
+            path = str(raw.get("path") or "")
+            if not path:
+                continue
+            old = str(raw.get("oldText") or "")
+            new = str(raw.get("newText") or "")
+            if not old:
+                parts.append(f"--- {path}\n+++ {path}\n(new file, {len(new)} bytes)")
+            else:
+                parts.append(
+                    f"--- {path}\n+++ {path}\n(edited: {len(old)} → {len(new)} bytes)"
+                )
+    return "\n".join(parts)
+
+
+def default_tool_name(title: str, kind: str = "") -> str:
+    return hermes_tool_name_from_title(title, kind)
+
+
+def hermes_tool_name_from_title(title: str, kind: str = "") -> str:
+    if title == "execute code":
+        return "execute_code"
+    if ":" in title:
+        name = title.split(":", 1)[0].strip()
+        if name == "terminal":
+            return "terminal"
+        if name == "read":
+            return "read_file"
+        if name == "write":
+            return "write_file"
+        if name.startswith("patch"):
+            return "patch"
+        if name == "search":
+            return "search_files"
+        if name == "web search":
+            return "web_search"
+        if name == "extract":
+            return "web_extract"
+        if name == "delegate":
+            return "delegate_task"
+        if name == "analyze image":
+            return "vision_analyze"
+        return name
+    kind_map = {
+        "read": "read_file",
+        "edit": "write_file",
+        "execute": "terminal",
+        "search": "search_files",
+        "fetch": "web_search",
+        "think": "thinking",
+    }
+    if kind in kind_map:
+        return kind_map[kind]
+    return title or kind
+
+
+def normalize_title_tool(title: str, mapping: dict[str, str] | None = None) -> str:
+    t = (title or "").strip()
+    if not t:
+        return ""
+    if ":" in t:
+        t = t.split(":", 1)[0].strip()
+    lower = t.lower()
+    base = {
+        "read": "read_file",
+        "read file": "read_file",
+        "write": "write_file",
+        "write file": "write_file",
+        "edit": "edit_file",
+        "patch": "edit_file",
+        "shell": "terminal",
+        "bash": "terminal",
+        "terminal": "terminal",
+        "run command": "terminal",
+        "run shell command": "terminal",
+        "execute": "terminal",
+        "grep": "search_files",
+        "search": "search_files",
+        "find": "search_files",
+        "glob": "glob",
+        "code": "code",
+        "web search": "web_search",
+        "fetch": "web_fetch",
+        "web fetch": "web_fetch",
+        "todo": "todo_write",
+        "todo write": "todo_write",
+        "todo list": "todo_write",
+        "todo_list": "todo_write",
+    }
+    if mapping:
+        base = {**base, **mapping}
+    if lower in base:
+        return base[lower]
+    return lower.replace(" ", "_")
+
+
+def kiro_tool_name(title: str, kind: str = "") -> str:
+    return normalize_title_tool(title) or hermes_tool_name_from_title(title, kind)
+
+
+def kimi_tool_name(title: str, kind: str = "") -> str:
+    # Upstream hermes mapping first, then kimi capitalised titles.
+    mapped = hermes_tool_name_from_title(title, kind)
+    return normalize_title_tool(mapped) or normalize_title_tool(title)
+
+
+def dsh_tool_name(title: str, kind: str = "") -> str:
+    return normalize_title_tool(title) or hermes_tool_name_from_title(title, kind)