velune-cli 0.9.0__py3-none-any.whl

velune/daemon/server.py

@@ -0,0 +1,127 @@
+import asyncio
+import os
+from pathlib import Path
+
+from velune.daemon.transport import DAEMON_PID_FILE, IpcServer, get_ipc_address
+
+
+class VeluneDaemon:
+    """Background daemon holding initialized subsystems."""
+
+    def __init__(self, workspace: Path):
+        self.workspace = workspace
+        self.runtime = None  # RuntimeContext
+        self._server = None
+
+    async def start(self):
+        """Initialize runtime and start IPC server."""
+        from velune.core.runtime import build_runtime
+
+        self.runtime = build_runtime(self.workspace)
+        await self.runtime.container.get("runtime.lifecycle").startup()
+
+        self._server = IpcServer(get_ipc_address(), self._dispatch)
+        await self._server.start()
+
+        # Write PID file
+        DAEMON_PID_FILE.parent.mkdir(parents=True, exist_ok=True)
+        DAEMON_PID_FILE.write_text(str(os.getpid()))
+
+        await self._server.serve_forever()
+
+    def shutdown(self):
+        if self._server:
+            self._server.close()
+        if DAEMON_PID_FILE.exists():
+            try:
+                DAEMON_PID_FILE.unlink()
+            except Exception:
+                pass
+
+    async def _dispatch(self, request: dict) -> dict:
+        """Route IPC request to appropriate handler."""
+        command = request.get("command")
+        if command == "ask":
+            return await self._handle_ask(request)
+        elif command == "models_list":
+            return await self._handle_models_list(request)
+        elif command == "probe_model":
+            return await self._handle_probe_model(request)
+        elif command == "ping":
+            return {"status": "ok", "pid": os.getpid()}
+        return {"error": f"Unknown command: {command}"}
+
+    async def _handle_ask(self, request: dict) -> dict:
+        # Phase 2 implementation placeholder
+        return {"status": "success", "response": "Phase 2 daemon execution."}
+
+    async def _handle_models_list(self, request: dict) -> dict:
+        try:
+            models = self.runtime.container.get("runtime.model_registry").list_all()
+            return {
+                "status": "success",
+                "models": [m.to_dict() if hasattr(m, "to_dict") else str(m) for m in models],
+            }
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    async def _handle_probe_model(self, request: dict) -> dict:
+        model_id = request.get("model_id")
+        provider_id = request.get("provider_id")
+        if not model_id or not provider_id:
+            return {"status": "error", "message": "Missing model_id or provider_id"}
+
+        async def run_probe():
+            try:
+                provider_reg = self.runtime.container.get("runtime.provider_registry")
+                provider = provider_reg.get(provider_id)
+                if not provider:
+                    return
+
+                from velune.models.probes import ModelProber
+                from velune.models.profile_cache import ModelProfileCache
+
+                profile_cache = ModelProfileCache(
+                    self.workspace / ".velune" / "model_profiles.json"
+                )
+
+                prober = ModelProber(provider, model_id)
+                results = await prober.run_all_probes()
+                profile_cache.set(model_id, provider_id, results)
+
+                # Also apply in-memory to daemon's registry
+                registry = self.runtime.container.get("runtime.model_registry")
+                if registry:
+                    model = registry.get(model_id, provider_id)
+                    if model:
+                        registry._apply_probe_results(model, results)
+            except Exception:
+                pass
+
+        asyncio.create_task(run_probe())
+        return {
+            "status": "success",
+            "message": f"Started probing for model {model_id} in daemon background.",
+        }
+
+
+if __name__ == "__main__":
+    import sys
+
+    from velune.daemon.client import DaemonClient
+    from velune.kernel.entrypoint import run_async
+
+    if len(sys.argv) < 2:
+        print("Usage: python -m velune.daemon.server <workspace_path>")
+        sys.exit(1)
+
+    if DaemonClient.is_running():
+        print("Daemon is already running.")
+        sys.exit(0)
+
+    workspace_path = Path(sys.argv[1]).resolve()
+    daemon = VeluneDaemon(workspace_path)
+    try:
+        run_async(daemon.start())
+    except KeyboardInterrupt:
+        daemon.shutdown()

velune/daemon/transport.py

@@ -0,0 +1,179 @@
+import asyncio
+import json
+import socket
+import sys
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+DAEMON_SOCKET_PATH = Path.home() / ".velune" / "daemon.sock"
+DAEMON_PID_FILE = Path.home() / ".velune" / "daemon.pid"
+DAEMON_PIPE_ADDRESS = r"\\.\pipe\velune_daemon"
+
+
+def get_ipc_address() -> str:
+    if sys.platform == "win32":
+        return DAEMON_PIPE_ADDRESS
+    return str(DAEMON_SOCKET_PATH)
+
+
+class IpcServer:
+    def __init__(self, address: str, handle_callback: Callable[[dict[str, Any]], Any]):
+        self.address = address
+        self.handle_callback = handle_callback
+        self._server = None
+        self._win_server = None
+
+    async def start(self):
+        # Ensure directories exist
+        if sys.platform != "win32":
+            socket_path = Path(self.address)
+            socket_path.parent.mkdir(parents=True, exist_ok=True)
+            if socket_path.exists():
+                try:
+                    socket_path.unlink()
+                except Exception:
+                    pass
+
+            self._server = await asyncio.start_unix_server(
+                self._handle_unix_client, path=self.address
+            )
+        else:
+            self._win_server = _WindowsNamedPipeServer(self.address, self.handle_callback)
+            self._win_server.start()
+
+    async def serve_forever(self):
+        if sys.platform != "win32":
+            await self._server.serve_forever()
+        else:
+            await self._win_server.serve_forever()
+
+    def close(self):
+        if self._server:
+            self._server.close()
+        if self._win_server:
+            self._win_server.close()
+
+    async def _handle_unix_client(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter):
+        try:
+            data = await reader.read(65536)
+            if not data:
+                return
+            request = json.loads(data.decode("utf-8"))
+            response = await self.handle_callback(request)
+            writer.write(json.dumps(response).encode("utf-8"))
+            await writer.drain()
+        except Exception:
+            pass
+        finally:
+            writer.close()
+
+
+class _WindowsNamedPipeServer:
+    def __init__(self, address: str, handle_callback: Callable[[dict[str, Any]], Any]):
+        self.address = address
+        self.handle_callback = handle_callback
+        self.listener = None
+        self.is_running = False
+
+    def start(self):
+        from multiprocessing.connection import Listener
+
+        self.listener = Listener(self.address, "AF_PIPE")
+        self.is_running = True
+
+    def close(self):
+        self.is_running = False
+        # Wake up the blocked accept() thread with a dummy connection on Windows
+        try:
+            from multiprocessing.connection import Client
+
+            conn = Client(self.address, "AF_PIPE")
+            conn.close()
+        except Exception:
+            pass
+        if self.listener:
+            try:
+                self.listener.close()
+            except Exception:
+                pass
+
+    async def serve_forever(self):
+        loop = asyncio.get_running_loop()
+        while self.is_running:
+            try:
+                conn = await loop.run_in_executor(None, self.listener.accept)
+                asyncio.create_task(self._handle_conn(conn))
+            except Exception:
+                if not self.is_running:
+                    break
+                await asyncio.sleep(0.1)
+
+    async def _handle_conn(self, conn):
+        try:
+            loop = asyncio.get_running_loop()
+            data = await loop.run_in_executor(None, conn.recv)
+            request = json.loads(data)
+            response = await self.handle_callback(request)
+            await loop.run_in_executor(None, conn.send, json.dumps(response))
+        except Exception:
+            pass
+        finally:
+            try:
+                conn.close()
+            except Exception:
+                pass
+
+
+class IpcClient:
+    @staticmethod
+    def is_running(address: str) -> bool:
+        if sys.platform != "win32":
+            socket_path = Path(address)
+            if not socket_path.exists():
+                return False
+            try:
+                sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+                sock.settimeout(1.0)
+                sock.connect(address)
+                sock.close()
+                return True
+            except Exception:
+                return False
+        else:
+            from multiprocessing.connection import Client
+
+            try:
+                conn = Client(address, "AF_PIPE")
+                conn.close()
+                return True
+            except Exception:
+                return False
+
+    @staticmethod
+    async def send_command(address: str, command: str, **kwargs) -> dict:
+        request = {"command": command, **kwargs}
+        if sys.platform != "win32":
+            reader, writer = await asyncio.open_unix_connection(address)
+            try:
+                writer.write(json.dumps(request).encode("utf-8"))
+                await writer.drain()
+                data = await reader.read(65536)
+                return json.loads(data.decode("utf-8"))
+            finally:
+                writer.close()
+        else:
+            from multiprocessing.connection import Client
+
+            loop = asyncio.get_running_loop()
+
+            def _send():
+                conn = Client(address, "AF_PIPE")
+                try:
+                    conn.send(json.dumps(request))
+                    res = conn.recv()
+                    return json.loads(res)
+                finally:
+                    conn.close()
+
+            return await loop.run_in_executor(None, _send)

velune/events.py

@@ -0,0 +1,204 @@
+"""Unified event types and CognitiveBus for Velune system."""
+
+from __future__ import annotations
+
+import asyncio
+import fnmatch
+import logging
+import uuid
+from collections import deque
+from collections.abc import AsyncIterator, Callable
+from datetime import UTC, datetime
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+logger = logging.getLogger("velune.events")
+
+_HISTORY_MAXLEN = 1000
+
+
+class Event(BaseModel):
+    """The central message token in the event bus."""
+
+    event_id: str = Field(default_factory=lambda: f"evt-{uuid.uuid4().hex[:12]}")
+    event_type: str
+    timestamp: float = Field(default_factory=lambda: datetime.now(tz=UTC).timestamp())
+    source: str
+    data: dict[str, Any] = Field(default_factory=dict)
+    correlation_id: str | None = None
+
+    class Config:
+        frozen = True
+
+
+EventHandler = Callable[[Event], None | Any]
+
+
+class Subscription:
+    """Subscription token allowing easy unsubscribe mechanics."""
+
+    def __init__(self, bus: CognitiveBus, event_type: str, handler: EventHandler) -> None:
+        self.bus = bus
+        self.event_type = event_type
+        self.handler = handler
+
+    def unsubscribe(self) -> None:
+        """Cancel this subscription."""
+        self.bus.unsubscribe(self.event_type, self.handler)
+
+
+class CognitiveBus:
+    """Async event bus supporting wildcard routing, replay, and correlation waiting."""
+
+    def __init__(self) -> None:
+        self._subscribers: dict[str, set[EventHandler]] = {}
+        self._queue: asyncio.Queue[Event] = asyncio.Queue()
+        self._running: bool = False
+        self._dispatch_task: asyncio.Task | None = None
+        self._history: deque[Event] = deque(maxlen=_HISTORY_MAXLEN)
+        self._pending_responses: dict[str, asyncio.Future[Event]] = {}
+
+    async def emit(self, event: Event) -> None:
+        """Enqueue/Publish a kernel event to the bus."""
+        if len(self._history) >= _HISTORY_MAXLEN:
+            oldest = self._history[0]
+            logger.debug(
+                "Event history at capacity (%d); dropping oldest: %s [%s]",
+                _HISTORY_MAXLEN,
+                oldest.event_type,
+                oldest.event_id,
+            )
+        self._history.append(event)
+
+        if event.correlation_id and event.correlation_id in self._pending_responses:
+            future = self._pending_responses[event.correlation_id]
+            if not future.done():
+                future.set_result(event)
+
+        if not self._running:
+            await self._dispatch_immediate(event)
+            return
+
+        await self._queue.put(event)
+
+    async def subscribe(self, event_type: str, handler: EventHandler) -> Subscription:
+        """Subscribe a handler to event types (supports wildcards like 'Memory*')."""
+        if event_type not in self._subscribers:
+            self._subscribers[event_type] = set()
+        self._subscribers[event_type].add(handler)
+        logger.debug("Subscribed to pattern '%s'", event_type)
+        return Subscription(self, event_type, handler)
+
+    def unsubscribe(self, event_type: str, handler: EventHandler) -> None:
+        """Remove subscriber handler from active pattern list."""
+        if event_type in self._subscribers and handler in self._subscribers[event_type]:
+            self._subscribers[event_type].remove(handler)
+            if not self._subscribers[event_type]:
+                del self._subscribers[event_type]
+            logger.debug("Unsubscribed from pattern '%s'", event_type)
+
+    async def emit_and_wait(self, event: Event, timeout: float = 5.0) -> Event:
+        """Emits an event and suspends execution until a correlating event returns."""
+        future: asyncio.Future[Event] = asyncio.get_running_loop().create_future()
+        self._pending_responses[event.event_id] = future
+
+        await self.emit(event)
+
+        try:
+            response = await asyncio.wait_for(future, timeout=timeout)
+            return response
+        except TimeoutError:
+            logger.error("Timeout waiting for correlation event to emitted ID: %s", event.event_id)
+            raise TimeoutError(f"Event correlation timeout for {event.event_id}")
+        finally:
+            self._pending_responses.pop(event.event_id, None)
+
+    async def replay(self, from_timestamp: datetime) -> AsyncIterator[Event]:
+        """Asynchronously stream events in history since from_timestamp."""
+        target_timestamp = from_timestamp.timestamp()
+        filtered_events = [evt for evt in self._history if evt.timestamp >= target_timestamp]
+
+        sorted_events = sorted(filtered_events, key=lambda x: x.timestamp)
+        for event in sorted_events:
+            yield event
+
+    async def start(self) -> None:
+        """Start the background event dispatch loop."""
+        if self._running:
+            return
+        self._running = True
+        self._dispatch_task = asyncio.create_task(self._dispatch_loop())
+        logger.info("Kernel Event Bus started.")
+
+    async def stop(self) -> None:
+        """Flush the queue and terminate the dispatch loop."""
+        self._running = False
+        if self._dispatch_task:
+            self._dispatch_task.cancel()
+            try:
+                await self._dispatch_task
+            except asyncio.CancelledError:
+                pass
+
+        while not self._queue.empty():
+            try:
+                event = self._queue.get_nowait()
+                await self._dispatch_immediate(event)
+            except Exception as e:
+                logger.error("Error processing queue flush event: %s", e)
+
+        logger.info("Kernel Event Bus stopped.")
+
+    async def _dispatch_loop(self) -> None:
+        """Background loop reading and routing events from the queue."""
+        while self._running:
+            try:
+                event = await self._queue.get()
+                await self._dispatch_immediate(event)
+                self._queue.task_done()
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                logger.error("Error in event bus dispatch loop: %s", e)
+
+    async def _dispatch_immediate(self, event: Event) -> None:
+        """Match event type and invoke all registered subscriber handlers."""
+        handlers_to_run = self._find_matching_handlers(event.event_type)
+        if not handlers_to_run:
+            return
+
+        tasks = []
+        for handler in handlers_to_run:
+            try:
+                if asyncio.iscoroutinefunction(handler):
+                    tasks.append(self._run_async_handler(handler, event))
+                else:
+                    handler(event)
+            except Exception as e:
+                logger.error("Error running synchronous event handler: %s", e)
+
+        if tasks:
+            await asyncio.gather(*tasks, return_exceptions=True)
+
+    async def _run_async_handler(self, handler: EventHandler, event: Event) -> None:
+        """Helper to run a coroutine handler with clean error capture."""
+        try:
+            await handler(event)
+        except Exception as e:
+            logger.error("Error running asynchronous event handler: %s", e)
+
+    def _find_matching_handlers(self, event_type: str) -> list[EventHandler]:
+        """Find all subscriber handlers whose pattern matches the event_type."""
+        matched: list[EventHandler] = []
+        for pattern, handlers in self._subscribers.items():
+            if fnmatch.fnmatchcase(event_type, pattern):
+                matched.extend(handlers)
+        return matched
+
+
+# Maintain legacy class name alias as fallback compatibility
+class EventBus(CognitiveBus):
+    """Fallback alias for compatibility with existing modules."""
+
+    pass

velune/execution/__init__.py

@@ -0,0 +1,22 @@
+"""Velune Isolated Sandbox, Execution DAG Planner, and Rollback Subsystem."""
+
+from velune.execution.checkpointer import FileCheckpointer
+from velune.execution.command_spec import CommandSpec
+from velune.execution.executor import ExecutionExecutor
+from velune.execution.planner import ExecutionDAG, ExecutionPlanner
+from velune.execution.rollback import RollbackManager
+from velune.execution.sandbox import SandboxResult, SubprocessSandbox
+from velune.execution.validator import PostExecutionValidator, ValidationResult
+
+__all__ = [
+    "SubprocessSandbox",
+    "SandboxResult",
+    "CommandSpec",
+    "FileCheckpointer",
+    "RollbackManager",
+    "PostExecutionValidator",
+    "ValidationResult",
+    "ExecutionDAG",
+    "ExecutionPlanner",
+    "ExecutionExecutor",
+]