delimit-cli 3.14.28 → 3.14.29

package/gateway/ai/local_server.py

@@ -0,0 +1,215 @@
+"""Local API server — serves ~/.delimit/ data over HTTP for dashboard access.
+
+Runs on localhost:7823. The dashboard connects here to show local data.
+No auth needed (localhost only). CORS enabled for app.delimit.ai.
+"""
+import json
+import os
+from pathlib import Path
+from http.server import HTTPServer, BaseHTTPRequestHandler
+
+def _get_delimit_home() -> Path:
+    return Path(os.environ.get("DELIMIT_HOME", str(Path.home() / ".delimit")))
+
+DELIMIT_HOME = _get_delimit_home()  # Default, can be overridden
+PORT = int(os.environ.get("DELIMIT_LOCAL_PORT", 7823))
+
+ALLOWED_ORIGINS = {
+    "https://app.delimit.ai",
+    "http://localhost:3000",
+    "http://localhost:3001",
+}
+
+
+class DelimitHandler(BaseHTTPRequestHandler):
+    """HTTP handler for the local Delimit API."""
+
+    def _get_origin(self):
+        origin = self.headers.get("Origin", "")
+        if origin in ALLOWED_ORIGINS:
+            return origin
+        return ""
+
+    def _send_cors_headers(self):
+        origin = self._get_origin()
+        if origin:
+            self.send_header("Access-Control-Allow-Origin", origin)
+        self.send_header("Access-Control-Allow-Methods", "GET, OPTIONS")
+        self.send_header("Access-Control-Allow-Headers", "Content-Type")
+        self.send_header("Vary", "Origin")
+
+    def do_GET(self):
+        path = self.path.split("?")[0]
+
+        routes = {
+            "/api/health": self.handle_health,
+            "/api/ledger": self.handle_ledger,
+            "/api/events": self.handle_events,
+            "/api/governance": self.handle_governance,
+            "/api/daemon": self.handle_daemon,
+            "/api/sessions": self.handle_sessions,
+        }
+
+        handler = routes.get(path)
+        if handler:
+            try:
+                data = handler()
+                self.send_response(200)
+                self.send_header("Content-Type", "application/json")
+                self._send_cors_headers()
+                self.end_headers()
+                self.wfile.write(json.dumps(data).encode())
+            except Exception as e:
+                self.send_response(500)
+                self.send_header("Content-Type", "application/json")
+                self._send_cors_headers()
+                self.end_headers()
+                self.wfile.write(json.dumps({"error": str(e)}).encode())
+        else:
+            self.send_response(404)
+            self.send_header("Content-Type", "application/json")
+            self._send_cors_headers()
+            self.end_headers()
+            self.wfile.write(json.dumps({"error": "Not found"}).encode())
+
+    def do_OPTIONS(self):
+        self.send_response(200)
+        self._send_cors_headers()
+        self.end_headers()
+
+    def log_message(self, format, *args):
+        """Suppress default stderr logging."""
+        pass
+
+    # ── Route handlers ──────────────────────────────────────────────
+
+    @staticmethod
+    def _home() -> Path:
+        """Read DELIMIT_HOME dynamically for testability."""
+        return Path(os.environ.get("DELIMIT_HOME", str(Path.home() / ".delimit")))
+
+    def handle_health(self):
+        return {
+            "status": "ok",
+            "port": PORT,
+            "home": str(self._home()),
+        }
+
+    def handle_ledger(self):
+        items = []
+        for fname in ["operations.jsonl", "strategy.jsonl"]:
+            fpath = self._home() / "ledger" / fname
+            if not fpath.exists():
+                continue
+            latest = {}
+            for line in fpath.read_text().splitlines():
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    entry = json.loads(line)
+                    entry_id = entry.get("id")
+                    if not entry_id:
+                        continue
+                    if entry.get("type") == "update" and entry_id in latest:
+                        latest[entry_id].update(entry)
+                    elif entry.get("type") != "update":
+                        latest[entry_id] = entry
+                except (json.JSONDecodeError, TypeError):
+                    pass
+            items.extend(latest.values())
+
+        open_items = [i for i in items if i.get("status") == "open"]
+        done_items = [i for i in items if i.get("status") == "done"]
+        return {
+            "items": items,
+            "summary": {
+                "total": len(items),
+                "open": len(open_items),
+                "done": len(done_items),
+            },
+        }
+
+    def handle_events(self):
+        events_dir = self._home() / "events"
+        if not events_dir.exists():
+            return {"events": []}
+        events = []
+        for f in sorted(events_dir.glob("events-*.jsonl"), reverse=True):
+            for line in reversed(f.read_text().splitlines()):
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    events.append(json.loads(line))
+                except (json.JSONDecodeError, TypeError):
+                    pass
+                if len(events) >= 50:
+                    break
+            if len(events) >= 50:
+                break
+        return {"events": events}
+
+    def handle_governance(self):
+        gov_dir = self._home() / "governance"
+        if not gov_dir.exists():
+            return {"checks": [], "overall": "unknown"}
+        checks = []
+        for f in gov_dir.glob("*.json"):
+            try:
+                checks.append(json.loads(f.read_text()))
+            except (json.JSONDecodeError, TypeError):
+                pass
+        overall = "pass" if checks and all(
+            c.get("status") == "pass" for c in checks
+        ) else "warn"
+        return {"checks": checks, "overall": overall}
+
+    def handle_daemon(self):
+        state_file = self._home() / "daemon" / "state.json"
+        if state_file.exists():
+            try:
+                return json.loads(state_file.read_text())
+            except (json.JSONDecodeError, TypeError):
+                pass
+        return {"status": "not_running", "loops": 0}
+
+    def handle_sessions(self):
+        sessions_dir = self._home() / "sessions"
+        if not sessions_dir.exists():
+            return {"sessions": []}
+        sessions = []
+        for f in sessions_dir.glob("*.json"):
+            try:
+                sessions.append(json.loads(f.read_text()))
+            except (json.JSONDecodeError, TypeError):
+                pass
+        return {"sessions": sessions}
+
+
+def start_server(port=None, background=True):
+    """Start the local API server.
+
+    Args:
+        port: Port to bind (default: DELIMIT_LOCAL_PORT env or 7823).
+        background: If True, run in a daemon thread and return the server.
+                    If False, block forever with serve_forever().
+
+    Returns:
+        The HTTPServer instance (background=True) or never returns (background=False).
+    """
+    if port is None:
+        port = PORT
+    server = HTTPServer(("127.0.0.1", port), DelimitHandler)
+    print(f"Delimit local server running on http://localhost:{port}")
+    if background:
+        import threading
+        t = threading.Thread(target=server.serve_forever, daemon=True)
+        t.start()
+        return server
+    else:
+        server.serve_forever()
+
+
+if __name__ == "__main__":
+    start_server(background=False)

package/gateway/ai/loop_engine.py

@@ -0,0 +1,408 @@
+"""Autonomous build loop engine — governed, throttled, cross-model.
+
+Provides the core loop primitives that any AI model can use via MCP:
+- next_task: get the next prioritized item with safeguard checks
+- task_complete: record completion, check if loop should continue
+- loop_status: current session metrics
+- loop_config: configure safeguards
+
+Session state persisted at ~/.delimit/loop/sessions/<session_id>.json
+"""
+
+import json
+import os
+import time
+import uuid
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+LOOP_DIR = Path.home() / ".delimit" / "loop"
+SESSIONS_DIR = LOOP_DIR / "sessions"
+
+# Actions the AI model must never auto-execute without human approval
+DEFAULT_REQUIRE_APPROVAL = ["deploy", "social_post", "outreach", "publish"]
+
+VALID_STATUSES = {"running", "paused", "stopped", "circuit_broken"}
+
+
+def _ensure_dir():
+    """Create the loop sessions directory if it doesn't exist."""
+    SESSIONS_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def _session_path(session_id: str) -> Path:
+    """Return the filesystem path for a session state file."""
+    return SESSIONS_DIR / f"{session_id}.json"
+
+
+def _load_session(session_id: str) -> Optional[Dict[str, Any]]:
+    """Load session state from disk. Returns None if not found."""
+    path = _session_path(session_id)
+    if not path.exists():
+        return None
+    try:
+        return json.loads(path.read_text())
+    except (json.JSONDecodeError, OSError):
+        return None
+
+
+def _save_session(session: Dict[str, Any]):
+    """Persist session state to disk."""
+    _ensure_dir()
+    path = _session_path(session["session_id"])
+    path.write_text(json.dumps(session, indent=2))
+
+
+def _create_session(session_id: str = "") -> Dict[str, Any]:
+    """Create a new loop session with default safeguards."""
+    if not session_id:
+        session_id = str(uuid.uuid4())[:12]
+    session = {
+        "session_id": session_id,
+        "started_at": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "iterations": 0,
+        "max_iterations": 50,
+        "cost_incurred": 0.0,
+        "cost_cap": 5.0,
+        "errors": 0,
+        "error_threshold": 3,
+        "tasks_completed": [],
+        "auto_consensus": False,
+        "require_approval_for": list(DEFAULT_REQUIRE_APPROVAL),
+        "status": "running",
+    }
+    _save_session(session)
+    return session
+
+
+def _get_or_create_session(session_id: str = "") -> Dict[str, Any]:
+    """Load an existing session or create a new one."""
+    if session_id:
+        existing = _load_session(session_id)
+        if existing:
+            return existing
+    return _create_session(session_id)
+
+
+def _check_safeguards(session: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """Check all safeguards. Returns a STOP action if any are tripped, else None."""
+    if session.get("status") == "paused":
+        return {
+            "action": "STOP",
+            "reason": "Loop is paused. Call loop_config to resume.",
+            "safeguard": "paused",
+        }
+
+    if session.get("status") == "stopped":
+        return {
+            "action": "STOP",
+            "reason": "Loop has been stopped.",
+            "safeguard": "stopped",
+        }
+
+    if session.get("status") == "circuit_broken":
+        return {
+            "action": "STOP",
+            "reason": f"Circuit breaker tripped after {session['errors']} errors.",
+            "safeguard": "circuit_breaker",
+        }
+
+    if session["iterations"] >= session["max_iterations"]:
+        return {
+            "action": "STOP",
+            "reason": f"Reached max iterations ({session['max_iterations']}).",
+            "safeguard": "max_iterations",
+        }
+
+    if session["cost_incurred"] >= session["cost_cap"]:
+        return {
+            "action": "STOP",
+            "reason": f"Cost cap reached (${session['cost_incurred']:.2f} >= ${session['cost_cap']:.2f}).",
+            "safeguard": "cost_cap",
+        }
+
+    if session["errors"] >= session["error_threshold"]:
+        session["status"] = "circuit_broken"
+        _save_session(session)
+        return {
+            "action": "STOP",
+            "reason": f"Circuit breaker: {session['errors']} errors hit threshold ({session['error_threshold']}).",
+            "safeguard": "circuit_breaker",
+        }
+
+    return None
+
+
+def _get_open_items(venture: str = "", project_path: str = ".") -> List[Dict[str, Any]]:
+    """Query the ledger for open items, sorted by priority."""
+    from ai.ledger_manager import list_items
+    result = list_items(status="open", project_path=project_path)
+    items = []
+    for ledger_items in result.get("items", {}).values():
+        items.extend(ledger_items)
+
+    # Sort by priority
+    priority_order = {"P0": 0, "P1": 1, "P2": 2, "P3": 3}
+    items.sort(key=lambda x: priority_order.get(x.get("priority", "P2"), 9))
+    return items
+
+
+def _filter_actionable(items: List[Dict[str, Any]], max_risk: str = "") -> List[Dict[str, Any]]:
+    """Filter out owner-only items and apply risk filtering.
+
+    Owner-only items are those with source='owner' or tags containing 'owner-action'.
+    """
+    filtered = []
+    for item in items:
+        # Skip owner-only items
+        tags = item.get("tags", [])
+        if "owner-action" in tags or "owner-only" in tags:
+            continue
+        if item.get("source") == "owner":
+            continue
+
+        # Risk filtering
+        if max_risk:
+            item_risk = item.get("risk", "")
+            if item_risk and _risk_level(item_risk) > _risk_level(max_risk):
+                continue
+
+        filtered.append(item)
+    return filtered
+
+
+def _resolve_project_path(venture: str) -> str:
+    """Resolve a venture name or path to a project directory path."""
+    if not venture:
+        return "."
+    # Direct path — use as-is
+    if venture.startswith("/") or venture.startswith("~"):
+        return str(Path(venture).expanduser())
+    if venture.startswith(".") or os.sep in venture:
+        return str(Path(venture).resolve())
+    # Try registered ventures
+    try:
+        from ai.ledger_manager import list_ventures
+        ventures = list_ventures()
+        for name, info in ventures.get("ventures", {}).items():
+            if name == venture or venture in name:
+                return info.get("path", ".")
+    except Exception:
+        pass
+    return "."
+
+
+def _risk_level(risk: str) -> int:
+    """Convert risk string to numeric level for comparison."""
+    levels = {"low": 1, "medium": 2, "high": 3, "critical": 4}
+    return levels.get(risk.lower(), 2)
+
+
+def next_task(
+    venture: str = "",
+    max_risk: str = "",
+    session_id: str = "",
+) -> Dict[str, Any]:
+    """Get the next task to work on with safeguard checks.
+
+    Returns:
+        Dict with action: BUILD (with task), CONSENSUS (generate new items), or STOP.
+    """
+    session = _get_or_create_session(session_id)
+
+    # Check safeguards
+    stop = _check_safeguards(session)
+    if stop:
+        stop["session"] = _session_summary(session)
+        return stop
+
+    # Resolve venture path
+    project_path = _resolve_project_path(venture)
+
+    # Get open items
+    items = _get_open_items(venture=venture, project_path=project_path)
+    actionable = _filter_actionable(items, max_risk=max_risk)
+
+    if not actionable:
+        if session.get("auto_consensus"):
+            return {
+                "action": "CONSENSUS",
+                "message": "No actionable items. Run consensus to generate new work.",
+                "session": _session_summary(session),
+            }
+        return {
+            "action": "STOP",
+            "reason": "No actionable items in the ledger.",
+            "safeguard": "empty_ledger",
+            "session": _session_summary(session),
+        }
+
+    task = actionable[0]
+
+    # Check if this task requires approval
+    require_approval = session.get("require_approval_for", [])
+    task_tags = task.get("tags", [])
+    needs_approval = any(tag in require_approval for tag in task_tags)
+    task_type = task.get("type", "")
+    if task_type in require_approval:
+        needs_approval = True
+
+    result = {
+        "action": "BUILD",
+        "task": task,
+        "remaining_items": len(actionable) - 1,
+        "session": _session_summary(session),
+    }
+    if needs_approval:
+        result["approval_required"] = True
+        result["approval_reason"] = "Task type or tags match require_approval_for list."
+
+    return result
+
+
+def task_complete(
+    task_id: str,
+    result: str = "",
+    cost_incurred: float = 0.0,
+    error: str = "",
+    session_id: str = "",
+    venture: str = "",
+) -> Dict[str, Any]:
+    """Mark current task done and get the next one.
+
+    Records completion, updates session metrics, returns the next task.
+    """
+    session = _get_or_create_session(session_id)
+
+    # Update metrics
+    session["iterations"] += 1
+    session["cost_incurred"] += cost_incurred
+
+    if error:
+        session["errors"] += 1
+        session["tasks_completed"].append({
+            "task_id": task_id,
+            "status": "error",
+            "error": error,
+            "completed_at": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
+            "cost": cost_incurred,
+        })
+    else:
+        session["tasks_completed"].append({
+            "task_id": task_id,
+            "status": "done",
+            "result": result[:500] if result else "",
+            "completed_at": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
+            "cost": cost_incurred,
+        })
+
+    _save_session(session)
+
+    # Mark ledger item as done (best-effort)
+    if not error:
+        try:
+            from ai.ledger_manager import update_item
+            project_path = _resolve_project_path(venture)
+            update_item(item_id=task_id, status="done", note=result[:200] if result else "Completed via build loop", project_path=project_path)
+        except Exception:
+            pass  # Never let ledger sync break the loop
+
+    # Return the next task
+    return next_task(venture=venture, session_id=session["session_id"])
+
+
+def loop_status(session_id: str = "") -> Dict[str, Any]:
+    """Return current session metrics."""
+    if not session_id:
+        # Try to find the most recent session
+        sessions = _list_sessions()
+        if not sessions:
+            return {"error": "No active loop sessions found."}
+        session_id = sessions[0]["session_id"]
+
+    session = _load_session(session_id)
+    if not session:
+        return {"error": f"Session {session_id} not found."}
+
+    return {
+        "session": _session_summary(session),
+        "tasks_completed": session.get("tasks_completed", []),
+        "safeguards": {
+            "max_iterations": session["max_iterations"],
+            "cost_cap": session["cost_cap"],
+            "error_threshold": session["error_threshold"],
+            "require_approval_for": session.get("require_approval_for", []),
+        },
+    }
+
+
+def loop_config(
+    session_id: str = "",
+    max_iterations: int = 0,
+    cost_cap: float = 0.0,
+    auto_consensus: Optional[bool] = None,
+    error_threshold: int = 0,
+    status: str = "",
+    require_approval_for: Optional[List[str]] = None,
+) -> Dict[str, Any]:
+    """Update session configuration. Only provided values are changed."""
+    session = _get_or_create_session(session_id)
+
+    changes = {}
+    if max_iterations > 0:
+        session["max_iterations"] = max_iterations
+        changes["max_iterations"] = max_iterations
+    if cost_cap > 0:
+        session["cost_cap"] = cost_cap
+        changes["cost_cap"] = cost_cap
+    if auto_consensus is not None:
+        session["auto_consensus"] = auto_consensus
+        changes["auto_consensus"] = auto_consensus
+    if error_threshold > 0:
+        session["error_threshold"] = error_threshold
+        changes["error_threshold"] = error_threshold
+    if status and status in VALID_STATUSES:
+        session["status"] = status
+        changes["status"] = status
+    if require_approval_for is not None:
+        session["require_approval_for"] = require_approval_for
+        changes["require_approval_for"] = require_approval_for
+
+    _save_session(session)
+
+    return {
+        "session_id": session["session_id"],
+        "changes": changes,
+        "current_config": _session_summary(session),
+    }
+
+
+def _session_summary(session: Dict[str, Any]) -> Dict[str, Any]:
+    """Return a concise session summary for inclusion in responses."""
+    return {
+        "session_id": session["session_id"],
+        "status": session["status"],
+        "iterations": session["iterations"],
+        "max_iterations": session["max_iterations"],
+        "cost_incurred": round(session["cost_incurred"], 4),
+        "cost_cap": session["cost_cap"],
+        "errors": session["errors"],
+        "error_threshold": session["error_threshold"],
+        "tasks_done": len(session.get("tasks_completed", [])),
+        "auto_consensus": session.get("auto_consensus", False),
+    }
+
+
+def _list_sessions() -> List[Dict[str, Any]]:
+    """List all sessions, most recent first."""
+    if not SESSIONS_DIR.exists():
+        return []
+    sessions = []
+    for f in SESSIONS_DIR.glob("*.json"):
+        try:
+            s = json.loads(f.read_text())
+            sessions.append(s)
+        except (json.JSONDecodeError, OSError):
+            continue
+    sessions.sort(key=lambda x: x.get("started_at", ""), reverse=True)
+    return sessions