@oneciel-ai/ciel-runtime 0.1.1 → 0.2.0

package/ciel_runtime_support/architecture_budget.py

@@ -0,0 +1,42 @@
+"""Enforce the bounded-context migration's monotonically decreasing budget."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+FINAL_FILE_LINE_BUDGET = 4_999
+MAIN_FILE_LINE_BUDGET = 12_989
+
+
+def production_python_files(root: Path) -> tuple[Path, ...]:
+    support = tuple(sorted((root / "ciel_runtime_support").rglob("*.py")))
+    entrypoints = (
+        root / "ciel_runtime.py",
+        root / "ciel-runtime-menu.py",
+        root / "ciel-runtime-tool-guard.py",
+    )
+    return tuple(path for path in (*entrypoints, *support) if path.is_file())
+
+
+def physical_line_count(path: Path) -> int:
+    return len(path.read_text(encoding="utf-8").splitlines())
+
+
+def architecture_budget_violations(root: Path) -> tuple[str, ...]:
+    violations: list[str] = []
+    main = root / "ciel_runtime.py"
+    main_lines = physical_line_count(main)
+    if main_lines > MAIN_FILE_LINE_BUDGET:
+        violations.append(
+            f"ciel_runtime.py has {main_lines} lines; ratchet budget is {MAIN_FILE_LINE_BUDGET}"
+        )
+    for path in production_python_files(root):
+        if path == main:
+            continue
+        lines = physical_line_count(path)
+        if lines > FINAL_FILE_LINE_BUDGET:
+            violations.append(
+                f"{path.relative_to(root)} has {lines} lines; file budget is {FINAL_FILE_LINE_BUDGET}"
+            )
+    return tuple(violations)

package/ciel_runtime_support/channel_backlog.py

@@ -0,0 +1,90 @@
+"""Application service for inspecting and discarding transient channel backlog."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelBacklogCursors:
+    scan_tail: Callable[[], int]
+    llm_lock: Any
+    read_llm: Callable[[], int]
+    write_llm: Callable[[int], None]
+    cache_llm: Callable[[int], None]
+    write_clear_floor: Callable[[int], None]
+    mcp_lock: Any
+    read_mcp: Callable[[], int]
+    write_mcp: Callable[[int], None]
+    cache_mcp: Callable[[int], None]
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelBacklogRuntime:
+    recovery_cache: dict[Any, Any]
+    session_lock: Any
+    sessions: dict[Any, dict[str, Any]]
+    condition: Any
+    log: Callable[[str, str], None]
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelBacklogService:
+    cursors: ChannelBacklogCursors
+    runtime: ChannelBacklogRuntime
+
+    def clear(self) -> dict[str, Any]:
+        tail = max(0, self.cursors.scan_tail())
+        with self.cursors.llm_lock:
+            old_llm = self.cursors.read_llm()
+            self.cursors.cache_llm(tail)
+            self._write_cursor("channel_llm_cursor", self.cursors.write_llm, tail)
+            self._write_cursor("channel_llm_clear_floor", self.cursors.write_clear_floor, tail)
+        self.runtime.recovery_cache.clear()
+        with self.cursors.mcp_lock:
+            old_mcp = self.cursors.read_mcp()
+            self.cursors.cache_mcp(tail)
+            self._write_cursor("channel_mcp_cursor", self.cursors.write_mcp, tail)
+        with self.runtime.session_lock:
+            for state in self.runtime.sessions.values():
+                try:
+                    state["last_id"] = max(int(state.get("last_id") or 0), tail)
+                except (TypeError, ValueError, OverflowError):
+                    state["last_id"] = tail
+            session_count = len(self.runtime.sessions)
+        with self.runtime.condition:
+            self.runtime.condition.notify_all()
+        stats = {
+            "chat_tail": tail,
+            "discarded_llm": max(0, tail - int(old_llm or 0)),
+            "discarded_mcp": max(0, tail - int(old_mcp or 0)),
+            "mcp_sessions_updated": session_count,
+        }
+        self.runtime.log(
+            "INFO",
+            f"channel_backlog_cleared chat_tail={tail} discarded_llm={stats['discarded_llm']} "
+            f"discarded_mcp={stats['discarded_mcp']} mcp_sessions_updated={session_count}",
+        )
+        return stats
+
+    def status(self) -> dict[str, Any]:
+        tail = max(0, self.cursors.scan_tail())
+        with self.cursors.llm_lock:
+            llm_cursor = self.cursors.read_llm()
+        with self.cursors.mcp_lock:
+            mcp_cursor = self.cursors.read_mcp()
+        return {
+            "chat_tail": tail,
+            "pending_llm": max(0, tail - int(llm_cursor or 0)),
+            "pending_mcp": max(0, tail - int(mcp_cursor or 0)),
+            "mcp_sessions": len(self.runtime.sessions),
+        }
+
+    def _write_cursor(self, name: str, writer: Callable[[int], None], tail: int) -> None:
+        try:
+            writer(tail)
+        except Exception as exc:
+            self.runtime.log("WARN", f"{name}_write_failed error={type(exc).__name__}: {exc}")
+
+
+__all__ = ["ChannelBacklogCursors", "ChannelBacklogRuntime", "ChannelBacklogService"]

package/ciel_runtime_support/channel_cli.py

@@ -0,0 +1,119 @@
+"""CLI controller for Channel configuration and capability probing."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable, Mapping
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelCliView:
+    load_config: Callable[[], dict[str, Any]]
+    status_text: Callable[[dict[str, Any]], str]
+    delivery_mode: Callable[[dict[str, Any] | None], str]
+    configured_specs: Callable[[dict[str, Any]], list[str]]
+    official_plugins: Mapping[str, str]
+    output: Callable[[str], None]
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelCliCommands:
+    add: Callable[[str], list[str]]
+    development: Callable[[bool], list[str]]
+    remove: Callable[[str], list[str]]
+    clear: Callable[[], list[str]]
+    refresh: Callable[[], dict[str, Any]]
+    report: Callable[[dict[str, Any]], list[str]]
+    set_delivery: Callable[[Any], list[str]]
+
+
+class ChannelCliController:
+    def __init__(self, view: ChannelCliView, commands: ChannelCliCommands) -> None:
+        self.view = view
+        self.commands = commands
+
+    def run(self, args: Any) -> None:
+        config = self.view.load_config()
+        values = list(getattr(args, "values", []) or [])
+        if not values:
+            self._status(config)
+            return
+        head = values[0].strip().lower()
+        if head in ("on", "enable", "add"):
+            self._require_value(values, "Usage: ciel-runtime channels add CHANNEL_SPEC")
+            self._lines(self.commands.add(values[1]))
+            return
+        if head in ("dev", "development"):
+            if len(values) >= 2 and values[1].lower() in (
+                "on",
+                "off",
+                "true",
+                "false",
+                "1",
+                "0",
+            ):
+                self._lines(self.commands.development(True))
+                return
+            self._require_value(values, "Usage: ciel-runtime channels add CHANNEL_SPEC")
+            self._lines(self.commands.add(values[1]))
+            return
+        if head in ("off", "disable", "remove", "rm"):
+            self._require_value(values, "Usage: ciel-runtime channels remove CHANNEL_SPEC")
+            self._lines(self.commands.remove(values[1]))
+            return
+        if head in ("clear", "reset"):
+            self._lines(self.commands.clear())
+            return
+        if head in ("detect", "probe", "refresh"):
+            try:
+                result = self.commands.refresh()
+            except Exception as exc:
+                raise SystemExit(
+                    f"Channel probe failed: {type(exc).__name__}: {exc}"
+                ) from exc
+            self._lines(self.commands.report(result))
+            return
+        if head in ("delivery", "mode"):
+            if len(values) < 2:
+                self.view.output(f"channel_delivery: {self.view.delivery_mode(config)}")
+            else:
+                self._lines(self.commands.set_delivery(values[1]))
+            return
+        if head in self.view.official_plugins:
+            spec = self.view.official_plugins[head]
+            command = (
+                self.commands.remove
+                if spec in self.view.configured_specs(config)
+                else self.commands.add
+            )
+            self._lines(command(spec))
+            return
+        self._lines(self.commands.add(values[0]))
+
+    def delivery(self, args: Any) -> None:
+        value = getattr(args, "value", None)
+        if value:
+            self._lines(self.commands.set_delivery(value))
+        else:
+            self.view.output(f"channel_delivery: {self.view.delivery_mode(None)}")
+
+    def _status(self, config: dict[str, Any]) -> None:
+        self.view.output(f"channels: {self.view.status_text(config)}")
+        self.view.output(f"delivery: {self.view.delivery_mode(config)}")
+        specs = self.view.configured_specs(config)
+        for name, spec in self.view.official_plugins.items():
+            mark = "*" if spec in specs else " "
+            self.view.output(f" {mark} {name:<10} {spec}")
+        official = set(self.view.official_plugins.values())
+        for spec in specs:
+            if spec not in official:
+                self.view.output(f" * custom    {spec}")
+
+    @staticmethod
+    def _require_value(values: list[str], message: str) -> None:
+        if len(values) < 2:
+            raise SystemExit(message)
+
+    def _lines(self, lines: list[str]) -> None:
+        for line in lines:
+            self.view.output(line)

package/ciel_runtime_support/channel_compact_injection.py

@@ -0,0 +1,82 @@
+"""Application service for injecting queued channel compaction commands."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelCompactRequestPorts:
+    read: Callable[[], dict[str, Any] | None]
+    clear: Callable[[str | None], None]
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelCompactRuntimePorts:
+    active_tool_call: Callable[[], bool]
+    active_turn: Callable[[], bool]
+    enter_bytes: Callable[[bytes | None], bytes]
+    write_prompt: Callable[..., None]
+    enter_label: Callable[[bytes], str]
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelCompactInjectionService:
+    request: ChannelCompactRequestPorts
+    runtime: ChannelCompactRuntimePorts
+    log: Callable[[str, str], None]
+
+    def inject(
+        self,
+        writer: Any,
+        enter_bytes: bytes | None = None,
+        *,
+        log_defer: bool = True,
+        submit_retry_count: int = 1,
+        confirm_submit: bool = False,
+        bracketed_paste: bool = False,
+        submit_delay_seconds: float | None = None,
+    ) -> str:
+        request = self.request.read()
+        if not request:
+            return "none"
+        request_id = str(request.get("id") or "")
+        if self.runtime.active_tool_call():
+            self._log_deferred(request_id, "active_tool_call", log_defer)
+            return "deferred"
+        if self.runtime.active_turn():
+            self._log_deferred(request_id, "active_turn", log_defer)
+            return "deferred"
+
+        command = str(request.get("command") or "/compact").strip() or "/compact"
+        if command != "/compact":
+            command = "/compact"
+        submit_bytes = self.runtime.enter_bytes(enter_bytes)
+        self.runtime.write_prompt(
+            writer,
+            command,
+            submit_bytes,
+            submit_retry_count=submit_retry_count,
+            confirm_submit=confirm_submit,
+            bracketed_paste=bracketed_paste,
+            submit_delay_seconds=submit_delay_seconds,
+        )
+        self.request.clear(request_id or None)
+        self.log(
+            "INFO",
+            f"channel_compact_request_injected id={request_id or '-'} "
+            f"enter={self.runtime.enter_label(submit_bytes)}",
+        )
+        return "injected"
+
+    def _log_deferred(
+        self, request_id: str, reason: str, enabled: bool
+    ) -> None:
+        if enabled:
+            self.log(
+                "INFO",
+                f"channel_compact_request_deferred id={request_id or '-'} "
+                f"reason={reason}",
+            )

package/ciel_runtime_support/channel_compact_poll.py

@@ -0,0 +1,67 @@
+"""Polling policy for injecting queued session compaction requests."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelCompactPollState:
+    last_poll_at: float = 0.0
+    defer_logged_at: float = 0.0
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelCompactInjectionOptions:
+    submit_retry_count: int
+    confirm_submit: bool
+    bracketed_paste: bool
+    submit_delay_seconds: float | None
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelCompactPollPolicy:
+    poll_interval_seconds: float = 0.5
+    defer_log_interval_seconds: float = 30.0
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelCompactPollServices:
+    inject_pending: Callable[..., str]
+
+
+def poll_pending_compaction(
+    now: float,
+    writer: Any,
+    enter_bytes: bytes,
+    inflight_message_id: int | None,
+    state: ChannelCompactPollState,
+    options: ChannelCompactInjectionOptions,
+    services: ChannelCompactPollServices,
+    policy: ChannelCompactPollPolicy = ChannelCompactPollPolicy(),
+    *,
+    input_ready: bool = True,
+) -> ChannelCompactPollState:
+    if not input_ready or now - state.last_poll_at < policy.poll_interval_seconds:
+        return state
+    if inflight_message_id is not None:
+        return ChannelCompactPollState(now, state.defer_logged_at)
+
+    log_defer = now - state.defer_logged_at >= policy.defer_log_interval_seconds
+    status = services.inject_pending(
+        writer,
+        enter_bytes,
+        log_defer=log_defer,
+        submit_retry_count=options.submit_retry_count,
+        confirm_submit=options.confirm_submit,
+        bracketed_paste=options.bracketed_paste,
+        submit_delay_seconds=options.submit_delay_seconds,
+    )
+    defer_logged_at = state.defer_logged_at
+    if status == "deferred" and log_defer:
+        defer_logged_at = now
+    elif status == "injected":
+        defer_logged_at = 0.0
+    return ChannelCompactPollState(now, defer_logged_at)

package/ciel_runtime_support/channel_compact_request_repository.py

@@ -0,0 +1,113 @@
+"""Persistent single-slot repository for channel-triggered compact requests."""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+import uuid
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+
+class ChannelCompactRequestRepository:
+    def __init__(
+        self,
+        path: Path,
+        lock: Any,
+        save: Callable[[dict[str, Any], str], None],
+        truncate: Callable[[str, int], str],
+        log: Callable[[str, str], None],
+        ttl: Callable[[], float],
+    ) -> None:
+        self.path = path
+        self.lock = lock
+        self.save = save
+        self.truncate = truncate
+        self.log = log
+        self.ttl = ttl
+
+    def payload(self, source: str, reason: str) -> dict[str, Any]:
+        now = time.time()
+        return {
+            "id": uuid.uuid4().hex,
+            "command": "/compact",
+            "source": str(source or "mcp"),
+            "reason": self.truncate(str(reason or ""), 1000),
+            "requested_at": now,
+            "expires_at": now + self.ttl(),
+            "pid": os.getpid(),
+        }
+
+    def queue(self, source: str = "mcp", reason: str = "") -> dict[str, Any]:
+        request = self.payload(source, reason)
+        with self.lock:
+            self.save(request, "channel_compact_request")
+        self.log(
+            "INFO",
+            f"channel_compact_request_queued id={request['id']} source={request['source']}",
+        )
+        return request
+
+    def read(self) -> dict[str, Any] | None:
+        with self.lock:
+            try:
+                data = json.loads(self.path.read_text(encoding="utf-8"))
+            except FileNotFoundError:
+                return None
+            except Exception as exc:
+                self.log(
+                    "WARN",
+                    f"channel_compact_request_read_failed error={type(exc).__name__}: {exc}",
+                )
+                return None
+            if not isinstance(data, dict):
+                return None
+            try:
+                expires_at = float(data.get("expires_at") or 0)
+            except Exception:
+                expires_at = 0.0
+            if expires_at and time.time() > expires_at:
+                self._unlink(str(data.get("id") or "-"))
+                self.log(
+                    "INFO", f"channel_compact_request_expired id={data.get('id') or '-'}"
+                )
+                return None
+            return data
+
+    def clear(self, request_id: str | None = None) -> bool:
+        with self.lock:
+            if request_id:
+                try:
+                    data = json.loads(self.path.read_text(encoding="utf-8"))
+                except FileNotFoundError:
+                    return False
+                except Exception:
+                    data = {}
+                if isinstance(data, dict) and str(data.get("id") or "") != str(request_id):
+                    return False
+            return self._unlink(request_id or "-", missing=False)
+
+    def _unlink(self, request_id: str, *, missing: bool = True) -> bool:
+        try:
+            self.path.unlink()
+            return True
+        except FileNotFoundError:
+            return missing
+        except Exception as exc:
+            self.log(
+                "WARN",
+                f"channel_compact_request_clear_failed id={request_id} "
+                f"error={type(exc).__name__}: {exc}",
+            )
+            return False
+
+
+def compact_request_ttl(value: str | None) -> float:
+    if value is None:
+        return 600.0
+    try:
+        return max(5.0, min(3600.0, float(str(value).strip())))
+    except (TypeError, ValueError):
+        return 600.0