openloom 0.7.0__py3-none-any.whl

openloom/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.7.0"

openloom/__main__.py

@@ -0,0 +1,3 @@
+from openloom.cli import main
+
+main()

openloom/cli.py

@@ -0,0 +1,212 @@
+from __future__ import annotations
+
+import argparse
+import asyncio
+import importlib.util
+import sys
+from typing import Any
+
+from openloom.config import Settings
+from openloom.core.events import EventBus
+from openloom.core.store import Store
+
+
+def _print_table(headers: list[str], rows: list[list[str]]) -> None:
+    col_widths = [len(h) for h in headers]
+    for row in rows:
+        for i, cell in enumerate(row):
+            col_widths[i] = max(col_widths[i], len(str(cell)))
+    fmt = "  ".join(f"{{:<{w}}}" for w in col_widths)
+    print(fmt.format(*headers))
+    print(fmt.format(*["─" * w for w in col_widths]))
+    for row in rows:
+        print(fmt.format(*[str(c) for c in row]))
+
+
+def _web_extras_available() -> bool:
+    return all(
+        importlib.util.find_spec(name) is not None
+        for name in ("fastapi", "uvicorn", "sse_starlette")
+    )
+
+
+def _require_web_extras() -> None:
+    if not _web_extras_available():
+        raise ImportError(
+            "Web UI requires FastAPI extras. Install with: pip install openloom[ui]"
+        )
+
+
+async def _run_watch_with_ui(
+    spec: str | None,
+    settings: Settings,
+    web_sink: Any,
+    *,
+    store_path: str,
+) -> None:
+    from openloom.server.app import create_app
+    import uvicorn
+    from openloom.levels.manual.watch import run_watch
+
+    store = Store(store_path)
+    bus = EventBus()
+    bus.subscribe_all(web_sink.on_event)
+
+    app = create_app(harness=None, store=store, bus=bus, web_sink=web_sink)
+    config = uvicorn.Config(
+        app, host=settings.ui_host, port=settings.ui_port, log_level="warning"
+    )
+    server = uvicorn.Server(config)
+    server_task = asyncio.create_task(server.serve())
+
+    try:
+        await run_watch(
+            spec,
+            settings,
+            store_path=store_path,
+            bus=bus,
+            web_sink=web_sink,
+        )
+    finally:
+        server.should_exit = True
+        server_task.cancel()
+        with asyncio.suppress(asyncio.CancelledError):
+            await server_task
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="openloom",
+        description="OpenLoom — lightweight agent task harness",
+    )
+    sub = parser.add_subparsers(dest="command")
+
+    watch_p = sub.add_parser("watch", help="Watch a task spec and manage the agent session")
+    watch_p.add_argument("spec", nargs="?", help="Path to task spec YAML (reads openloom.yaml if omitted)")
+    watch_p.add_argument("--ui", action="store_true", help="Start web UI on http://127.0.0.1:55413")
+
+    serve_p = sub.add_parser("serve", help="Start OpenLoom server (multi-task, web dashboard)")
+    serve_p.add_argument("--host", help="Bind host (default: 127.0.0.1)")
+    serve_p.add_argument("--port", type=int, help="Bind port (default: 55413)")
+
+    init_p = sub.add_parser("init", help="Generate openloom.yaml in the current directory")
+    init_p.add_argument("--path", help="Target path (default: ./openloom.yaml)")
+
+    sub.add_parser("status", help="List all tasks from the store")
+
+    log_p = sub.add_parser("log", help="Show check log for a task")
+    log_p.add_argument("task_id", help="Task ID (prefix match supported)")
+
+    args = parser.parse_args()
+    settings = Settings.from_env()
+
+    if args.command == "init":
+        from openloom.levels.config.spec import generate_config
+
+        try:
+            path = generate_config(args.path)
+            print(f"Created {path}")
+        except FileExistsError as e:
+            print(f"ERROR: {e}")
+            sys.exit(1)
+
+    elif args.command == "watch":
+        store_path = str(settings.database_path)
+        if args.ui:
+            try:
+                _require_web_extras()
+            except ImportError as e:
+                print(f"ERROR: {e}")
+                sys.exit(1)
+            from openloom.levels.ui.sink import WebSink
+
+            web_sink = WebSink()
+            asyncio.run(
+                _run_watch_with_ui(
+                    args.spec, settings, web_sink, store_path=store_path
+                )
+            )
+        else:
+            from openloom.levels.manual.watch import run_watch
+
+            asyncio.run(run_watch(args.spec, settings, store_path=store_path))
+
+    elif args.command == "serve":
+        import openloom.levels.manual.checker  # noqa: F401
+        import openloom.levels.manual.sink  # noqa: F401
+        import openloom.levels.ui.sink  # noqa: F401
+        from openloom.levels.server.serve import run_serve
+
+        if args.host:
+            settings = Settings(
+                opencode_url=settings.opencode_url,
+                opencode_username=settings.opencode_username,
+                opencode_password=settings.opencode_password,
+                database_path=settings.database_path,
+                allowed_roots=settings.allowed_roots,
+                strict_roots=settings.strict_roots,
+                ui_host=args.host,
+                ui_port=args.port or settings.ui_port,
+            )
+        elif args.port:
+            settings = Settings(
+                opencode_url=settings.opencode_url,
+                opencode_username=settings.opencode_username,
+                opencode_password=settings.opencode_password,
+                database_path=settings.database_path,
+                allowed_roots=settings.allowed_roots,
+                strict_roots=settings.strict_roots,
+                ui_port=args.port,
+            )
+
+        asyncio.run(run_serve(settings))
+
+    elif args.command == "status":
+        store = Store(settings.database_path)
+        tasks = store.list_tasks()
+        if not tasks:
+            print("No tasks found.")
+            return
+        headers = ["ID", "Name", "Status", "Progress", "Last Summary"]
+        rows = [
+            [
+                t["id"][:12],
+                t.get("name", "")[:40],
+                t.get("status", ""),
+                f"{t.get('progress', 0):.0%}",
+                (t.get("last_summary") or "")[:50],
+            ]
+            for t in tasks
+        ]
+        _print_table(headers, rows)
+
+    elif args.command == "log":
+        import datetime
+
+        store = Store(settings.database_path)
+        prefix = args.task_id
+        tasks = store.list_tasks()
+        match = next((t for t in tasks if t["id"].startswith(prefix)), None)
+        if not match:
+            print(f"No task found matching '{prefix}'")
+            sys.exit(1)
+        task = store.get_task(match["id"])
+        print(f"Task:  {task['id']} — {task.get('name', '')}")
+        print(f"Status: {task.get('status', '')}  Progress: {task.get('progress', 0):.0%}")
+        print()
+        log = task.get("check_log") or []
+        for entry in log[-20:]:
+            ts = entry.get("at", 0)
+            dt = datetime.datetime.fromtimestamp(ts).strftime("%H:%M:%S")
+            print(f"  [{dt}] {entry.get('status', '')}")
+            print(f"         {entry.get('summary', '')}")
+        if len(log) > 20:
+            print(f"  ... ({len(log) - 20} more entries)")
+
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

openloom/config.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+
+def _split_paths(value: str) -> list[Path]:
+    paths: list[Path] = []
+    for item in value.split(":"):
+        item = item.strip()
+        if not item:
+            continue
+        paths.append(Path(item).expanduser().resolve())
+    return paths
+
+
+def _env_bool(name: str, default: bool = False) -> bool:
+    raw = os.getenv(name)
+    if raw is None:
+        return default
+    return raw.strip().lower() in {"1", "true", "yes", "on"}
+
+
+@dataclass(frozen=True)
+class Settings:
+    opencode_url: str
+    opencode_username: str
+    opencode_password: str
+    database_path: Path
+    allowed_roots: list[Path]
+    strict_roots: bool
+    ui_host: str = "127.0.0.1"
+    ui_port: int = 55413
+
+    @classmethod
+    def from_env(cls) -> Settings:
+        database = Path(os.getenv("OPENLOOM_DATABASE", ".openloom/openloom.sqlite3")).expanduser()
+        if not database.is_absolute():
+            database = Path.cwd() / database
+        roots = _split_paths(os.getenv("OPENLOOM_ALLOWED_ROOTS", ""))
+
+        return cls(
+            opencode_url=os.getenv("OPENLOOM_OPENCODE_URL", "http://127.0.0.1:14096").rstrip("/"),
+            opencode_username=os.getenv("OPENLOOM_OPENCODE_USERNAME", "opencode"),
+            opencode_password=os.getenv("OPENLOOM_OPENCODE_PASSWORD", "xxx"),
+            database_path=database,
+            allowed_roots=roots,
+            strict_roots=_env_bool("OPENLOOM_STRICT_ROOTS", default=False),
+            ui_host=os.getenv("OPENLOOM_UI_HOST", "127.0.0.1"),
+            ui_port=int(os.getenv("OPENLOOM_UI_PORT", "55413")),
+        )
+
+    def is_allowed_workspace(self, cwd: str) -> bool:
+        path = Path(cwd).expanduser().resolve()
+        if not path.exists() or not path.is_dir():
+            return False
+        if not self.strict_roots:
+            return True
+        if not self.allowed_roots:
+            return False
+        return any(path == root or root in path.parents for root in self.allowed_roots)

openloom/core/checker.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class CheckResult:
+    task_complete: bool = False
+    step_done: int = 0
+    acceptance_checked: int = 0
+    acceptance_total: int = 0
+    acceptance_progress: float = 0.0
+
+
+class Checker(ABC):
+    @abstractmethod
+    def check(self, messages: list[dict[str, Any]], spec: dict[str, Any]) -> CheckResult:
+        ...

openloom/core/events.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import logging
+import time
+from collections import defaultdict
+from dataclasses import dataclass, field
+from enum import Enum, auto
+from typing import Any, Callable
+
+_logger = logging.getLogger("openloom.events")
+
+
+class EventType(Enum):
+    TASK_CREATED = auto()
+    TASK_STARTED = auto()
+    TASK_UPDATED = auto()
+    TASK_COMPLETED = auto()
+    TASK_FAILED = auto()
+    LOG_LINE = auto()
+
+
+@dataclass(frozen=True)
+class Event:
+    type: EventType
+    task_id: str
+    timestamp: float = field(default_factory=time.time)
+    store_version: int = 0
+    data: dict[str, Any] = field(default_factory=dict)
+
+
+class EventBus:
+    def __init__(self) -> None:
+        self._subscribers: dict[EventType, list[Callable[[Event], None]]] = defaultdict(list)
+        self._wildcards: list[Callable[[Event], None]] = []
+
+    def subscribe(self, event_type: EventType, handler: Callable[[Event], None]) -> None:
+        self._subscribers[event_type].append(handler)
+
+    def subscribe_all(self, handler: Callable[[Event], None]) -> None:
+        self._wildcards.append(handler)
+
+    def emit(self, event: Event) -> None:
+        for handler in (*self._subscribers.get(event.type, ()), *self._wildcards):
+            try:
+                handler(event)
+            except Exception:
+                _logger.exception("Event handler %r failed for %s", handler, event.type.name)

openloom/core/harness.py

@@ -0,0 +1,290 @@
+from __future__ import annotations
+
+import time
+import uuid
+from typing import Any
+
+from .checker import CheckResult
+from .events import Event, EventBus, EventType
+
+
+class HarnessRunner:
+    def __init__(self, opencode: Any, bus: EventBus, store: Any, checker: Any, prompts: Any, status: Any, allowed_workspace: Any = None) -> None:
+        self.opencode = opencode
+        self.bus = bus
+        self.store = store
+        self.checker = checker
+        self.prompts = prompts
+        self.status = status
+        self.allowed_workspace = allowed_workspace or (lambda _: True)
+
+    def add_task(self, spec: Any, task_id: str | None = None) -> str:
+        if not hasattr(spec, "to_dict"):
+            spec = self.prompts.TaskSpec.from_dict(spec)
+
+        task_id = task_id or f"task_{uuid.uuid4().hex[:12]}"
+        now = time.time()
+        task = {
+            "id": task_id,
+            "name": spec.name,
+            "spec": spec.to_dict(),
+            "workspace": spec.workspace,
+            "status": "pending",
+            "current_step": 0,
+            "completed_steps": [],
+            "idle_checks": 0,
+            "progress": 0.0,
+            "check_interval_seconds": spec.check_interval_seconds,
+            "last_check_at": None,
+            "next_check_at": now,
+            "active_session_id": None,
+            "session_ids": [],
+            "last_summary": None,
+            "error": None,
+            "check_log": [],
+        }
+        result = self.store.create_task(task)
+        sv = result.get("store_version", 0)
+
+        self.bus.emit(Event(type=EventType.TASK_CREATED, task_id=task_id, store_version=sv,
+                            data={"spec": spec.to_dict(), "workspace": spec.workspace}))
+        return task_id
+
+    async def tick(self) -> None:
+        due = self.store.list_due_tasks()
+        for task in due:
+            try:
+                await self._check_task(task)
+            except Exception as exc:  # noqa: BLE001
+                sv = self.store.update_task(task["id"], status="failed", error=str(exc))
+                self.store.append_check_log(
+                    task["id"], status="failed", summary="Harness check failed", detail=str(exc),
+                )
+                self.bus.emit(Event(
+                    type=EventType.TASK_FAILED,
+                    task_id=task["id"],
+                    store_version=sv,
+                    data={"error": str(exc), "summary": "Harness check failed"},
+                ))
+
+    async def _check_task(self, task: dict[str, Any]) -> None:
+        task_id = task["id"]
+        spec_data = task["spec"]
+        now = time.time()
+
+        if task["status"] == "pending":
+            await self._start_task(task)
+            return
+
+        if task["status"] in ("paused", "completed", "failed", "archived"):
+            return
+
+        session_id = task.get("active_session_id")
+        if not session_id:
+            await self._start_task(task)
+            return
+
+        spec = self.prompts.TaskSpec.from_dict(spec_data)
+
+        live_raw = await self.opencode.session_status()
+        live = live_raw.get(session_id)
+        status_text = self.status.normalize_session_status(live) or ""
+
+        messages = await self.opencode.messages(session_id, limit=50)
+        is_busy = self.prompts.messages_indicate_busy(messages)
+
+        result: CheckResult = self.checker.check(messages, spec_data)
+
+        current_step = int(task.get("current_step") or 0)
+        if result.step_done > 0:
+            current_step = max(current_step, min(result.step_done, len(spec.steps) - 1))
+
+        completed_steps = list(task.get("completed_steps") or [])
+        all_steps_reported = len(spec.steps) > 0 and result.step_done >= len(spec.steps)
+        task_finished = (
+            result.task_complete
+            or (spec.acceptance and result.acceptance_checked >= len(spec.acceptance))
+            or all_steps_reported
+        )
+
+        if is_busy:
+            status = "running"
+            summary = "Agent is busy"
+        elif status_text == self.status.RETRY or "wait" in status_text or "permission" in status_text:
+            status = "waiting"
+            summary = "Waiting for permission or input"
+        elif task_finished:
+            status = "completed"
+            summary = "Agent reported TASK COMPLETE" if result.task_complete else "All steps appear complete"
+        else:
+            status = "running"
+            summary = "Session idle — verifying progress"
+            agent_name: str | None = None if spec.agent == "opencode" else spec.agent
+            nudge: str | None = None
+
+            if self.prompts.needs_continue_reply(messages):
+                step_name = spec.steps[min(current_step, len(spec.steps) - 1)]
+                nudge = (
+                    f"Yes — proceed autonomously with step {current_step + 1}: {step_name}. "
+                    "Do not ask for confirmation between harness steps; implement directly. "
+                    f"Reply with STEP DONE: {current_step + 1} when this step is finished."
+                )
+                summary = f"Auto-continued to step {current_step + 1}"
+            elif (
+                result.step_done > 0
+                and result.step_done not in completed_steps
+                and current_step < len(spec.steps) - 1
+            ):
+                next_index = min(result.step_done, len(spec.steps) - 1)
+                nudge = (
+                    f"Continue harness task '{spec.name}'. "
+                    f"Focus on step {next_index + 1}: {spec.steps[next_index]}. "
+                    "Proceed without asking for permission. "
+                    "Reply with STEP DONE: <number> or TASK COMPLETE when appropriate."
+                )
+                current_step = next_index
+                summary = f"Nudged agent toward step {next_index + 1}"
+            else:
+                nudge = self.prompts.build_periodic_check_prompt(
+                    spec,
+                    current_step=current_step,
+                    progress={
+                        "task_complete": result.task_complete,
+                        "step_done": result.step_done,
+                        "acceptance_checked": result.acceptance_checked,
+                        "acceptance_total": result.acceptance_total,
+                        "acceptance_progress": result.acceptance_progress,
+                    },
+                    completed_steps=completed_steps,
+                )
+                summary = "Periodic check — requested status confirmation"
+
+            if nudge:
+                await self.opencode.send_prompt_async(
+                    session_id=session_id,
+                    prompt=nudge,
+                    agent=agent_name,
+                )
+
+        if result.step_done > 0 and result.step_done not in completed_steps:
+            completed_steps.append(result.step_done)
+
+        total_steps = len(spec.steps)
+        if status == "completed":
+            step_progress = 1.0
+        elif total_steps:
+            step_progress = min(1.0, len(completed_steps) / total_steps)
+        else:
+            step_progress = 1.0 if task_finished else 0.0
+
+        idle_checks = int(task.get("idle_checks") or 0)
+        if not is_busy:
+            idle_checks += 1
+        else:
+            idle_checks = 0
+
+        interval = int(task.get("check_interval_seconds", 300))
+        next_check = None if status in ("completed", "failed", "archived") else now + interval
+
+        sv = self.store.update_task(
+            task_id,
+            status=status,
+            current_step=current_step,
+            completed_steps=completed_steps,
+            idle_checks=idle_checks,
+            progress=step_progress,
+            last_check_at=now,
+            next_check_at=next_check,
+            last_summary=summary,
+        )
+        self.store.append_check_log(task_id, status=status, summary=summary, detail=status_text)
+
+        self.bus.emit(Event(
+            type=EventType.TASK_UPDATED,
+            task_id=task_id,
+            store_version=sv,
+            data={
+                "status": status,
+                "current_step": current_step,
+                "progress": step_progress,
+                "summary": summary,
+            },
+        ))
+
+        if status == "completed":
+            self.bus.emit(Event(type=EventType.TASK_COMPLETED, task_id=task_id, store_version=sv,
+                                data={"summary": summary, "progress": step_progress}))
+        elif status == "failed":
+            self.bus.emit(Event(type=EventType.TASK_FAILED, task_id=task_id, store_version=sv, data={"summary": summary}))
+
+    async def _start_task(self, task: dict[str, Any]) -> None:
+        task_id = task["id"]
+        spec = self.prompts.TaskSpec.from_dict(task["spec"])
+        session_id = task.get("active_session_id")
+        attached = bool(session_id)
+
+        if session_id:
+            try:
+                sessions = await self.opencode.list_sessions()
+            except Exception:
+                sessions = []
+            match = next((s for s in sessions if s.get("id") == session_id), None)
+            if not match:
+                raise ValueError(f"Session {session_id} no longer exists")
+            directory = match.get("directory") or spec.workspace
+            if directory and self.allowed_workspace(directory):
+                spec = self.prompts.TaskSpec.from_dict({**spec.to_dict(), "workspace": directory})
+        else:
+            if not self.allowed_workspace(spec.workspace):
+                raise ValueError("Workspace is outside allowed roots")
+            session = await self.opencode.create_session(cwd=spec.workspace, title=spec.name)
+            session_id = session["id"]
+
+        raw_interval = task.get("check_interval_seconds")
+        interval = int(raw_interval if raw_interval is not None else spec.check_interval_seconds)
+        one_shot = interval <= 0
+        structured = bool(spec.steps or spec.acceptance or spec.step_acceptance)
+        if structured or not one_shot:
+            prompt = self.prompts.build_bootstrap_prompt(
+                spec, current_step=int(task.get("current_step") or 0),
+            )
+        else:
+            prompt = spec.initial_prompt or spec.goal
+        if not prompt:
+            raise ValueError("Task requires a prompt or structured plan")
+
+        await self.opencode.send_prompt_async(
+            session_id=session_id,
+            prompt=prompt,
+            agent=None if spec.agent == "opencode" else spec.agent,
+        )
+
+        session_ids = list(task.get("session_ids") or [])
+        if session_id not in session_ids:
+            session_ids.append(session_id)
+
+        now = time.time()
+        summary = (
+            (f"Prompt sent to session {session_id}" if attached else "Prompt sent")
+            if one_shot
+            else (f"Harness attached to session {session_id}" if attached else "Harness started and bootstrap prompt sent")
+        )
+        sv = self.store.update_task(
+            task_id,
+            status="running",
+            active_session_id=session_id,
+            session_ids=session_ids,
+            spec=spec.to_dict(),
+            last_check_at=now,
+            next_check_at=None if one_shot else now + interval,
+            error=None,
+        )
+        self.store.append_check_log(task_id, status="running", summary=summary, detail=f"session={session_id}")
+        self.bus.emit(Event(type=EventType.TASK_STARTED, task_id=task_id, store_version=sv,
+                            data={"session_id": session_id, "summary": summary}))
+
+    def get_task(self, task_id: str) -> dict[str, Any] | None:
+        return self.store.get_task(task_id)
+
+    def list_tasks(self) -> list[dict[str, Any]]:
+        return self.store.list_tasks()