modastack 0.2.0__py3-none-any.whl

dashboard/app.py

@@ -0,0 +1,219 @@
+"""FastAPI dashboard — view layer for modastack."""
+
+import asyncio
+import json
+import logging
+import time
+from pathlib import Path
+
+from fastapi import FastAPI, Query, Request
+from fastapi.responses import HTMLResponse
+from fastapi.templating import Jinja2Templates
+
+from . import data
+
+log = logging.getLogger(__name__)
+
+app = FastAPI(title="modastack dashboard")
+templates = Jinja2Templates(directory=str(Path(__file__).parent / "templates"))
+
+
+@app.get("/", response_class=HTMLResponse)
+async def index(request: Request):
+    return templates.TemplateResponse(request, "index.html")
+
+
+@app.get("/api/status")
+async def api_status():
+    manager, engineers = await asyncio.gather(
+        asyncio.to_thread(data.get_manager_status),
+        asyncio.to_thread(data.get_sessions),
+    )
+    return {"manager": manager, "engineers": engineers}
+
+
+@app.get("/api/events")
+async def api_events(
+    limit: int = Query(50, ge=1, le=500),
+    offset: int = Query(0, ge=0),
+    source: str | None = Query(None),
+    type: str | None = Query(None),
+):
+    events, total = data.read_events(
+        limit=limit, offset=offset, source=source, type_filter=type
+    )
+    return {"events": events, "total": total}
+
+
+@app.get("/api/decisions")
+async def api_decisions(limit: int = Query(10, ge=1, le=100)):
+    return {"decisions": data.read_decisions(limit=limit)}
+
+
+@app.get("/api/sources")
+async def api_sources():
+    return {"sources": data.get_event_sources()}
+
+
+@app.get("/api/log")
+async def api_log(limit: int = Query(50, ge=1, le=200), session: str = Query("")):
+    if not session:
+        session = data._get_manager_session_name()
+    return {"turns": data.get_conversation_log(limit=limit, session=session)}
+
+
+@app.get("/api/logs")
+async def api_logs(limit: int = Query(200, ge=1, le=2000)):
+    """Tail of the modastack process log (~/.modastack/modastack.log)."""
+    lines = await asyncio.to_thread(data.read_modastack_log, limit)
+    return {"lines": lines}
+
+
+@app.post("/api/message")
+async def api_send_message(request: Request):
+    body = await request.json()
+    text = body.get("text", "").strip()
+    if not text:
+        return {"ok": False, "error": "empty message"}
+    from modastack.manager.session import inject, is_alive
+    if not is_alive():
+        return {"ok": False, "error": "manager not running"}
+    inject(text)
+    return {"ok": True}
+
+
+@app.post("/api/event")
+async def api_post_event(request: Request):
+    """Enqueue a synthetic event onto the same queue webhooks use.
+
+    Used by out-of-band check processes (`modastack spawn --non-interactive
+    --post-event ...`) to report findings without touching the manager's
+    conversation — the drain loop routes it like any other event.
+    """
+    body = await request.json()
+    etype = (body.get("type") or "").strip()
+    if not etype:
+        return {"ok": False, "error": "missing event type"}
+
+    from modastack.manager.events.event_client import event_queue
+    event = {
+        "type": etype,
+        "source": (body.get("source") or "monitor").strip(),
+        "data": body.get("data") or {},
+    }
+    event_queue.put(event)
+    return {"ok": True}
+
+
+@app.post("/api/consult")
+async def api_consult(request: Request):
+    body = await request.json()
+    question = body.get("question", "").strip()
+    timeout = body.get("timeout", 300)
+    source = body.get("source", "engineer")
+    correlation_id = body.get("correlation_id", "")
+
+    if not question:
+        return {"ok": False, "error": "empty question"}
+
+    from modastack.manager.session import is_alive
+    if not is_alive():
+        return {"ok": False, "error": "manager not running"}
+
+    result = await asyncio.to_thread(
+        _do_consult, question, timeout, source, correlation_id
+    )
+    return result
+
+
+def _do_consult(question, timeout, source, correlation_id):
+    from modastack.manager.session import inject_capture, last_inject_error
+
+    _log_consultation(correlation_id, source, question)
+
+    ok, response = inject_capture(
+        f"[CONSULTATION] {question}",
+        timeout=timeout,
+        wait_for_ready=timeout,
+    )
+    if not ok:
+        return {"ok": False, "error": f"inject failed: {last_inject_error()}"}
+
+    return {"ok": True, "response": response or "", "correlation_id": correlation_id}
+
+
+def _log_consultation(correlation_id: str, source: str, question: str):
+    events_log = Path.home() / ".modastack" / "manager" / "events.jsonl"
+    events_log.parent.mkdir(parents=True, exist_ok=True)
+    entry = {
+        "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S"),
+        "type": "consultation.request",
+        "source": source,
+        "data": {
+            "correlation_id": correlation_id,
+            "question": question[:500],
+        },
+    }
+    with open(events_log, "a") as f:
+        f.write(json.dumps(entry) + "\n")
+
+
+@app.post("/api/engineers/{issue_id}/message")
+async def api_send_engineer_message(issue_id: str, request: Request):
+    body = await request.json()
+    text = body.get("text", "").strip()
+    if not text:
+        return {"ok": False, "error": "empty message"}
+
+    # Direct injection only works if the engineer sub-agent is running in
+    # this process (legacy fire-and-forget path). The supervised executor
+    # runs phases to completion without a live inbox, so fall back to
+    # relaying the feedback through the manager, who coordinates engineers.
+    from modastack.subagent import inject_message
+    if inject_message(issue_id, text):
+        return {"ok": True, "delivery": "direct"}
+
+    from modastack.manager.session import inject, is_alive
+    if not is_alive():
+        return {"ok": False, "error": "manager not running and no live engineer session"}
+
+    title = ""
+    entry = data.get_registry().get(f"eng-{issue_id.lower()}") or _engineer_entry(issue_id)
+    if entry:
+        title = entry.title
+    relay = (
+        f"[ENGINEER FEEDBACK] For engineer working on #{issue_id}"
+        + (f" ({title})" if title else "")
+        + f": {text}\n\nRelay this to the engineer or act on it as appropriate."
+    )
+    ok = await asyncio.to_thread(inject, relay, timeout=120, wait_for_ready=120)
+    if ok:
+        return {"ok": True, "delivery": "manager"}
+    return {"ok": False, "error": "could not deliver — manager busy or unavailable"}
+
+
+def _engineer_entry(issue_id: str):
+    """Find the most recent registry entry for an issue across phases."""
+    registry = data.get_registry()
+    matches = [
+        e for e in registry.get_by_role("engineer")
+        if e.issue_id.lower() == issue_id.lower()
+    ]
+    if not matches:
+        return None
+    return max(matches, key=lambda e: e.last_activity)
+
+
+@app.get("/api/workflow/{issue_id}")
+async def api_workflow_progress(issue_id: str):
+    progress = data.get_workflow_progress(issue_id)
+    if not progress:
+        return {"progress": None}
+    return {"progress": progress}
+
+
+def run_dashboard(port: int = 8095) -> None:
+    import uvicorn
+
+    log.info(f"Starting dashboard on http://localhost:{port}")
+    uvicorn.run(app, host="0.0.0.0", port=port, log_level="info")

dashboard/data.py

@@ -0,0 +1,240 @@
+"""Read-only data access for the dashboard.
+
+Reads events, activity log, and session registry.
+"""
+
+import json
+import os
+from pathlib import Path
+
+from modastack.config import GLOBAL_CONFIG_DIR
+from modastack.sdk import get_registry, SessionRegistry
+from modastack.workflow.state import WorkflowRun
+from modastack.workflow.schema import load_workflow
+
+def _state_file(name: str) -> Path:
+    from modastack.sdk import get_repo_root
+    root = get_repo_root()
+    if root:
+        return root / ".modastack" / "state" / name
+    return GLOBAL_CONFIG_DIR / name
+
+
+def _log_path() -> Path:
+    return _state_file("manager.log")
+
+
+def _tail_lines(path: Path, limit: int) -> list[str]:
+    """Return the last `limit` lines of a file without reading it whole.
+
+    Seeks backward from the end in chunks so an unbounded log (the
+    modastack daemon's stdout sink never rotates) stays cheap to poll.
+    """
+    if not path.exists():
+        return []
+    block = 64 * 1024
+    with open(path, "rb") as f:
+        f.seek(0, os.SEEK_END)
+        size = f.tell()
+        data = b""
+        newlines = 0
+        pos = size
+        while pos > 0 and newlines <= limit:
+            read = min(block, pos)
+            pos -= read
+            f.seek(pos)
+            chunk = f.read(read)
+            data = chunk + data
+            newlines += chunk.count(b"\n")
+    text = data.decode("utf-8", errors="replace")
+    return text.splitlines()[-limit:]
+
+
+def _read_jsonl_tail(path: Path, limit: int) -> list[dict]:
+    if not path.exists():
+        return []
+    lines = path.read_text().strip().splitlines()
+    result = []
+    for line in reversed(lines):
+        try:
+            result.append(json.loads(line))
+        except json.JSONDecodeError:
+            continue
+        if len(result) >= limit:
+            break
+    return result
+
+
+def read_events(
+    limit: int = 50,
+    offset: int = 0,
+    source: str | None = None,
+    type_filter: str | None = None,
+) -> tuple[list[dict], int]:
+    if not _state_file("events.jsonl").exists():
+        return [], 0
+
+    lines = _state_file("events.jsonl").read_text().strip().splitlines()
+    all_events = []
+    for line in reversed(lines):
+        try:
+            event = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if source and event.get("source") != source:
+            continue
+        if type_filter and type_filter not in event.get("type", ""):
+            continue
+        all_events.append(event)
+
+    total = len(all_events)
+    return all_events[offset : offset + limit], total
+
+
+def read_decisions(limit: int = 10) -> list[dict]:
+    return _read_jsonl_tail(_state_file("decisions.jsonl"), limit)
+
+
+def _is_running() -> bool:
+    if not _state_file("manager.pid").exists():
+        return False
+    try:
+        pid = int(_state_file("manager.pid").read_text().strip())
+        os.kill(pid, 0)
+        return True
+    except (ValueError, ProcessLookupError, PermissionError):
+        return False
+
+
+def _activity_snippet(session: str, length: int = 120) -> str:
+    """Most recent assistant response text for a session, truncated.
+
+    Only scans the tail of the log — the latest response is near the end,
+    and these files are polled on the async /api/status path.
+    """
+    log_path = SessionRegistry.log_path(session)
+    for line in reversed(_tail_lines(log_path, 200)):
+        try:
+            entry = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if entry.get("event") == "response":
+            text = (entry.get("text") or "").strip().replace("\n", " ")
+            return text[:length] + ("…" if len(text) > length else "")
+    return ""
+
+
+def _get_manager_session_name() -> str:
+    from modastack.manager.session import get_default_session
+    session = get_default_session()
+    return session.session_name if session else "moda-manager"
+
+
+def get_manager_status() -> dict:
+    from modastack.sdk import load_session_id
+    name = _get_manager_session_name()
+    running = _is_running()
+    session_id = load_session_id(name) or ""
+    registry = get_registry()
+    entry = registry.get(name)
+    status = entry.status if entry else ("running" if running else "stopped")
+    return {
+        "alive": running,
+        "state": status,
+        "session_id": session_id[:8] if session_id else "",
+        "activity": _activity_snippet(name),
+        "last_activity": entry.last_activity if entry else 0,
+    }
+
+
+def get_sessions() -> list[dict]:
+    registry = get_registry()
+    engineers = [e for e in registry.get_by_role("engineer") if e.status not in ("done", "cancelled")]
+    result = []
+    for e in engineers:
+        result.append({
+            "name": e.name,
+            "issue_id": e.issue_id,
+            "title": e.title,
+            "phase": e.phase,
+            "repo": e.repo,
+            "cwd": e.cwd,
+            "status": e.status,
+            "started_at": e.started_at,
+            "last_activity": e.last_activity,
+            "activity": _activity_snippet(e.name),
+        })
+    return result
+
+
+def read_modastack_log(limit: int = 200) -> list[str]:
+    """Return the last `limit` lines of the modastack process log."""
+    return _tail_lines(_log_path(), limit)
+
+
+def get_conversation_log(limit: int = 50, session: str = "") -> list[dict]:
+    if not session:
+        session = _get_manager_session_name()
+    log_path = SessionRegistry.log_path(session)
+    if not log_path.exists():
+        return []
+    lines = log_path.read_text().strip().splitlines()
+    turns = []
+    for line in reversed(lines):
+        try:
+            turns.append(json.loads(line))
+        except json.JSONDecodeError:
+            continue
+        if len(turns) >= limit:
+            break
+    return turns
+
+
+def get_event_sources() -> list[str]:
+    if not _state_file("events.jsonl").exists():
+        return []
+    sources = set()
+    for line in _state_file("events.jsonl").read_text().strip().splitlines()[-200:]:
+        try:
+            sources.add(json.loads(line).get("source", ""))
+        except json.JSONDecodeError:
+            continue
+    return sorted(s for s in sources if s)
+
+
+def _load_workflow_info(workflow_name: str) -> tuple[dict[str, str], list[str]]:
+    from modastack.workflow.triggers import WORKFLOWS_DIR, USER_WORKFLOWS_DIR
+    for d in [USER_WORKFLOWS_DIR, WORKFLOWS_DIR]:
+        path = d / f"{workflow_name}.yaml"
+        if path.exists():
+            try:
+                wf = load_workflow(path)
+                labels = {nid: n.label for nid, n in wf.nodes.items() if n.label}
+                order = wf.topological_order()
+                return labels, order
+            except Exception:
+                pass
+    return {}, []
+
+
+def get_workflow_progress(issue_id: str) -> dict | None:
+    for run in WorkflowRun.list_runs():
+        trigger_data = run.trigger_event.get("data", {})
+        rid = trigger_data.get("issue_id", "")
+        if rid.lstrip("#").lower() == issue_id.lower():
+            labels, all_node_ids = _load_workflow_info(run.workflow_name)
+            nodes = []
+            for nid in all_node_ids:
+                ns = run.nodes.get(nid)
+                nodes.append({
+                    "id": nid,
+                    "label": labels.get(nid, ""),
+                    "status": ns.status if ns else "pending",
+                })
+            return {
+                "run_id": run.run_id,
+                "workflow": run.workflow_name,
+                "status": run.status,
+                "nodes": nodes,
+            }
+    return None