nexo-brain 2.6.21 → 3.0.0

package/src/skills_runtime.py

@@ -18,6 +18,7 @@ from db import (
     approve_skill,
     collect_skill_improvement_candidates,
     collect_scriptable_skill_candidates,
+    create_skill,
     get_featured_skills,
     get_skill,
     get_skill_execution_spec,
@@ -32,6 +33,7 @@ from script_registry import doctor_script
 
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
 NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parent)))
+VALID_LEVELS = {"trace", "draft", "published", "stable", "archived"}
 
 
 def _parse_params(params) -> dict:
@@ -160,6 +162,155 @@ def get_featured_skill_summaries(limit: int = 5) -> list[dict]:
     return featured
 
 
+def _skill_json_list(skill: dict, key: str) -> list:
+    try:
+        value = json.loads(skill.get(key, "[]"))
+    except json.JSONDecodeError:
+        value = []
+    return value if isinstance(value, list) else []
+
+
+def test_skill(skill_id: str, params=None, mode: str = "auto", context: str = "") -> dict:
+    result = apply_skill(skill_id, params=params, mode=mode, dry_run=True, context=context or "skill_test")
+    result["tested"] = True
+    result["test_kind"] = "dry_run"
+    return result
+
+
+def promote_skill(skill_id: str, target_level: str = "published", reason: str = "") -> dict:
+    _ensure_ready()
+    sync_skill_directories()
+    skill = get_skill(skill_id)
+    if not skill:
+        return {"ok": False, "error": f"Skill {skill_id} not found"}
+    clean_target = str(target_level or "published").strip().lower()
+    if clean_target not in VALID_LEVELS:
+        return {"ok": False, "error": f"Unsupported target_level: {target_level}"}
+    if clean_target == "archived":
+        return {"ok": False, "error": "Use retire_skill to archive skills explicitly"}
+    updated = update_skill(skill_id, level=clean_target)
+    if "error" in updated:
+        return {"ok": False, "error": updated["error"]}
+    return {
+        "ok": True,
+        "skill_id": skill_id,
+        "previous_level": skill.get("level", ""),
+        "level": updated.get("level", clean_target),
+        "reason": str(reason or "").strip(),
+    }
+
+
+def retire_skill(skill_id: str, replacement_id: str = "", reason: str = "") -> dict:
+    _ensure_ready()
+    sync_skill_directories()
+    skill = get_skill(skill_id)
+    if not skill:
+        return {"ok": False, "error": f"Skill {skill_id} not found"}
+    replacement = None
+    clean_replacement = str(replacement_id or "").strip()
+    if clean_replacement:
+        replacement = get_skill(clean_replacement)
+        if not replacement:
+            return {"ok": False, "error": f"Replacement skill {clean_replacement} not found"}
+    updated = update_skill(skill_id, level="archived")
+    if "error" in updated:
+        return {"ok": False, "error": updated["error"]}
+    return {
+        "ok": True,
+        "skill_id": skill_id,
+        "level": updated.get("level", "archived"),
+        "replacement_id": clean_replacement,
+        "reason": str(reason or "").strip(),
+    }
+
+
+def compose_skills(
+    *,
+    new_skill_id: str,
+    name: str,
+    component_ids: list[str],
+    description: str = "",
+    level: str = "draft",
+    mode: str = "guide",
+    tags: list[str] | None = None,
+    trigger_patterns: list[str] | None = None,
+) -> dict:
+    _ensure_ready()
+    sync_skill_directories()
+    if get_skill(new_skill_id):
+        return {"ok": False, "error": f"Skill {new_skill_id} already exists"}
+    components = []
+    for skill_id in component_ids:
+        skill = get_skill(skill_id)
+        if not skill:
+            return {"ok": False, "error": f"Component skill {skill_id} not found"}
+        components.append(skill)
+    if not components:
+        return {"ok": False, "error": "At least one component skill is required"}
+
+    merged_steps: list[str] = []
+    merged_gotchas: list[str] = []
+    merged_tags = set(tags or [])
+    merged_triggers = set(trigger_patterns or [])
+    linked_learnings = set()
+    source_sessions = set()
+    content_lines = [f"# {name}", "", description or "Composite skill built from existing NEXO skills.", "", "## Components"]
+    for skill in components:
+        content_lines.append(f"- {skill['id']}: {skill['name']}")
+        for step in _skill_json_list(skill, "steps"):
+            if step and step not in merged_steps:
+                merged_steps.append(step)
+        for gotcha in _skill_json_list(skill, "gotchas"):
+            if gotcha and gotcha not in merged_gotchas:
+                merged_gotchas.append(gotcha)
+        for trigger in _skill_json_list(skill, "trigger_patterns"):
+            if trigger:
+                merged_triggers.add(trigger)
+        for tag in _skill_json_list(skill, "tags"):
+            if tag:
+                merged_tags.add(tag)
+        for item in _skill_json_list(skill, "linked_learnings"):
+            if item:
+                linked_learnings.add(item)
+        for item in _skill_json_list(skill, "source_sessions"):
+            if item:
+                source_sessions.add(item)
+
+    if merged_steps:
+        content_lines.extend(["", "## Steps"])
+        for index, step in enumerate(merged_steps, 1):
+            content_lines.append(f"{index}. {step}")
+    if merged_gotchas:
+        content_lines.extend(["", "## Gotchas"])
+        for gotcha in merged_gotchas:
+            content_lines.append(f"- {gotcha}")
+
+    created = create_skill(
+        skill_id=new_skill_id,
+        name=name,
+        description=description or f"Composite skill built from {', '.join(component_ids)}",
+        level=level,
+        tags=sorted(merged_tags),
+        trigger_patterns=sorted(merged_triggers),
+        source_sessions=sorted(source_sessions),
+        linked_learnings=sorted(linked_learnings),
+        steps=merged_steps,
+        gotchas=merged_gotchas,
+        content="\n".join(content_lines).strip() + "\n",
+        mode=mode,
+        source_kind="personal",
+    )
+    if "error" in created:
+        return {"ok": False, "error": created["error"]}
+    return {
+        "ok": True,
+        "skill_id": new_skill_id,
+        "component_ids": component_ids,
+        "level": created.get("level", level),
+        "mode": created.get("mode", mode),
+    }
+
+
 def apply_skill(skill_id: str, params=None, mode: str = "auto", dry_run: bool = False, context: str = "") -> dict:
     _ensure_ready()
     sync_skill_directories()

package/src/state_watchers_runtime.py

@@ -0,0 +1,334 @@
+from __future__ import annotations
+"""Runtime evaluation for persistent state watchers."""
+
+import json
+import os
+import sqlite3
+import subprocess
+from datetime import UTC, datetime, timedelta
+from pathlib import Path
+from urllib import error, request
+
+
+def _nexo_home() -> Path:
+    return Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+
+
+def _db_path() -> Path:
+    explicit = os.environ.get("NEXO_TEST_DB") or os.environ.get("NEXO_DB")
+    if explicit:
+        return Path(explicit)
+    return _nexo_home() / "data" / "nexo.db"
+
+
+def _summary_file() -> Path:
+    return _nexo_home() / "operations" / "state-watchers-status.json"
+
+
+def _manifest_file() -> Path:
+    return _nexo_home() / "crons" / "manifest.json"
+
+
+def _now_iso() -> str:
+    return datetime.now(UTC).strftime("%Y-%m-%d %H:%M:%S")
+
+
+def _parse_dt(value: str | None) -> datetime | None:
+    text = str(value or "").strip()
+    if not text:
+        return None
+    normalized = text.replace("Z", "+00:00")
+    for candidate in (normalized, normalized + "T00:00:00+00:00"):
+        try:
+            parsed = datetime.fromisoformat(candidate)
+            return parsed if parsed.tzinfo else parsed.replace(tzinfo=UTC)
+        except Exception:
+            continue
+    for fmt in ("%Y-%m-%d", "%Y-%m-%d %H:%M:%S"):
+        try:
+            parsed = datetime.strptime(text, fmt)
+            return parsed.replace(tzinfo=UTC)
+        except Exception:
+            continue
+    return None
+
+
+def _load_manifest() -> list[dict]:
+    manifest_file = _manifest_file()
+    if not manifest_file.is_file():
+        return []
+    try:
+        payload = json.loads(manifest_file.read_text())
+    except Exception:
+        return []
+    crons = payload.get("crons")
+    return crons if isinstance(crons, list) else []
+
+
+def _load_last_cron_run(cron_id: str) -> datetime | None:
+    db_path = _db_path()
+    if not db_path.is_file():
+        return None
+    conn = sqlite3.connect(str(db_path))
+    row = conn.execute(
+        "SELECT started_at FROM cron_runs WHERE cron_id = ? ORDER BY started_at DESC LIMIT 1",
+        (cron_id,),
+    ).fetchone()
+    conn.close()
+    if not row or not row[0]:
+        return None
+    return _parse_dt(str(row[0]))
+
+
+def _evaluate_repo_drift(watcher: dict) -> dict:
+    repo_path = Path(str(watcher.get("target") or "")).expanduser()
+    if not repo_path.exists():
+        return {"health": "critical", "summary": f"repo path missing: {repo_path}", "evidence": [str(repo_path)]}
+    try:
+        inside = subprocess.run(
+            ["git", "rev-parse", "--is-inside-work-tree"],
+            cwd=str(repo_path),
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+    except Exception as exc:
+        return {"health": "critical", "summary": f"git probe failed: {exc}", "evidence": [str(repo_path)]}
+    if inside.returncode != 0 or inside.stdout.strip() != "true":
+        return {"health": "critical", "summary": f"not a git repo: {repo_path}", "evidence": [inside.stderr.strip() or inside.stdout.strip()]}
+
+    branch = subprocess.run(
+        ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+        cwd=str(repo_path),
+        capture_output=True,
+        text=True,
+        timeout=5,
+    )
+    status = subprocess.run(
+        ["git", "status", "--porcelain"],
+        cwd=str(repo_path),
+        capture_output=True,
+        text=True,
+        timeout=5,
+    )
+    config = watcher.get("config") or {}
+    expected_branch = str(config.get("expected_branch") or "").strip()
+    dirty = bool(status.stdout.strip())
+    health = "healthy"
+    evidence = [f"branch={branch.stdout.strip() or 'unknown'}", f"dirty={dirty}"]
+    summary = f"repo clean at {repo_path}"
+    if expected_branch and branch.stdout.strip() and branch.stdout.strip() != expected_branch:
+        health = "degraded"
+        summary = f"repo branch drifted from {expected_branch}"
+        evidence.append(f"expected_branch={expected_branch}")
+    if dirty and not bool(config.get("allow_dirty")):
+        health = "degraded" if health == "healthy" else health
+        summary = f"repo has uncommitted drift at {repo_path}"
+        evidence.extend(status.stdout.strip().splitlines()[:5])
+    return {"health": health, "summary": summary, "evidence": evidence}
+
+
+def _cron_threshold_seconds(cron_payload: dict) -> int | None:
+    if cron_payload.get("interval_seconds"):
+        return max(int(cron_payload["interval_seconds"]) * 2, 900)
+    if cron_payload.get("schedule"):
+        return 36 * 3600
+    if cron_payload.get("run_at_load"):
+        return None
+    return 24 * 3600
+
+
+def _evaluate_cron_drift(watcher: dict) -> dict:
+    cron_id = str(watcher.get("target") or "").strip()
+    manifest = _load_manifest()
+    cron_payload = next((item for item in manifest if str(item.get("id") or "").strip() == cron_id), None)
+    if not cron_payload:
+        return {"health": "critical", "summary": f"cron missing from manifest: {cron_id}", "evidence": [str(_manifest_file())]}
+    threshold = _cron_threshold_seconds(cron_payload)
+    if threshold is None:
+        return {"health": "healthy", "summary": f"cron {cron_id} is run_at_load-only", "evidence": ["no periodic freshness expected"]}
+    last_run = _load_last_cron_run(cron_id)
+    if not last_run:
+        return {"health": "critical", "summary": f"cron {cron_id} has never run", "evidence": [f"threshold_seconds={threshold}"]}
+    age = (datetime.now(UTC) - last_run).total_seconds()
+    if age > threshold * 2:
+        health = "critical"
+    elif age > threshold:
+        health = "degraded"
+    else:
+        health = "healthy"
+    return {
+        "health": health,
+        "summary": f"cron {cron_id} freshness checked",
+        "evidence": [f"age_seconds={int(age)}", f"threshold_seconds={threshold}", f"last_run={last_run.isoformat()}"],
+    }
+
+
+def _evaluate_api_health(watcher: dict) -> dict:
+    url = str(watcher.get("target") or "").strip()
+    config = watcher.get("config") or {}
+    timeout = float(config.get("timeout_seconds") or 3)
+    allowed_min = int(config.get("allowed_min") or 200)
+    allowed_max = int(config.get("allowed_max") or 399)
+    method = str(config.get("method") or "GET").upper()
+    req = request.Request(url, method=method)
+    try:
+        with request.urlopen(req, timeout=timeout) as resp:
+            code = int(getattr(resp, "status", 200))
+    except error.HTTPError as exc:
+        code = int(exc.code)
+    except Exception as exc:
+        return {"health": "critical", "summary": f"API health probe failed for {url}", "evidence": [str(exc)]}
+    health = "healthy" if allowed_min <= code <= allowed_max else "critical"
+    return {
+        "health": health,
+        "summary": f"API {url} returned {code}",
+        "evidence": [f"status_code={code}", f"allowed={allowed_min}-{allowed_max}"],
+    }
+
+
+def _evaluate_environment_drift(watcher: dict) -> dict:
+    config = watcher.get("config") or {}
+    mode = str(config.get("mode") or "env_var").strip().lower()
+    target = str(watcher.get("target") or "").strip()
+    if mode == "env_var":
+        current = os.environ.get(target, "")
+        expected = str(config.get("expected_value") or "").strip()
+        if not current:
+            return {"health": "critical", "summary": f"env var missing: {target}", "evidence": [target]}
+        if expected and current != expected:
+            return {"health": "degraded", "summary": f"env var drift: {target}", "evidence": [f"expected={expected}", f"current={current}"]}
+        return {"health": "healthy", "summary": f"env var present: {target}", "evidence": [target]}
+    path = Path(target).expanduser()
+    if mode == "dir_exists":
+        healthy = path.is_dir()
+    else:
+        healthy = path.exists()
+    return {
+        "health": "healthy" if healthy else "critical",
+        "summary": f"{mode} {'OK' if healthy else 'missing'} for {path}",
+        "evidence": [str(path)],
+    }
+
+
+def _evaluate_expiry(watcher: dict) -> dict:
+    config = watcher.get("config") or {}
+    due_at = _parse_dt(str(config.get("due_at") or watcher.get("target") or ""))
+    if not due_at:
+        return {"health": "critical", "summary": f"expiry watcher missing due_at: {watcher.get('watcher_id')}", "evidence": []}
+    warn_days = int(config.get("warn_days") or 21)
+    critical_days = int(config.get("critical_days") or 7)
+    remaining = due_at - datetime.now(UTC)
+    days = remaining.total_seconds() / 86400
+    if days <= critical_days:
+        health = "critical"
+    elif days <= warn_days:
+        health = "degraded"
+    else:
+        health = "healthy"
+    return {
+        "health": health,
+        "summary": f"expiry watcher '{watcher.get('title')}' due in {days:.1f} days",
+        "evidence": [f"due_at={due_at.isoformat()}", f"warn_days={warn_days}", f"critical_days={critical_days}"],
+    }
+
+
+def evaluate_state_watcher(watcher: dict) -> dict:
+    watcher_type = str(watcher.get("watcher_type") or "").strip().lower()
+    if watcher_type == "repo_drift":
+        result = _evaluate_repo_drift(watcher)
+    elif watcher_type == "cron_drift":
+        result = _evaluate_cron_drift(watcher)
+    elif watcher_type == "api_health":
+        result = _evaluate_api_health(watcher)
+    elif watcher_type == "environment_drift":
+        result = _evaluate_environment_drift(watcher)
+    elif watcher_type == "expiry":
+        result = _evaluate_expiry(watcher)
+    else:
+        result = {"health": "critical", "summary": f"unsupported watcher type: {watcher_type}", "evidence": []}
+    return {
+        "watcher_id": watcher.get("watcher_id", ""),
+        "title": watcher.get("title", ""),
+        "watcher_type": watcher_type,
+        "target": watcher.get("target", ""),
+        "severity": watcher.get("severity", "warn"),
+        "checked_at": _now_iso(),
+        **result,
+    }
+
+
+def _list_watchers(*, status: str) -> list[dict]:
+    db_path = _db_path()
+    if not db_path.is_file():
+        return []
+    conn = sqlite3.connect(str(db_path))
+    conn.row_factory = sqlite3.Row
+    clauses = []
+    params = []
+    if status:
+        clauses.append("status = ?")
+        params.append(status)
+    where = f"WHERE {' AND '.join(clauses)}" if clauses else ""
+    try:
+        rows = conn.execute(
+            f"""SELECT watcher_id, watcher_type, title, target, severity, status, config, last_health, last_result, last_checked_at
+                FROM state_watchers
+                {where}
+                ORDER BY updated_at DESC, watcher_id DESC""",
+            tuple(params),
+        ).fetchall()
+    except sqlite3.OperationalError:
+        conn.close()
+        return []
+    conn.close()
+    watchers = []
+    for row in rows:
+        watcher = dict(row)
+        try:
+            watcher["config"] = json.loads(watcher.get("config") or "{}")
+        except Exception:
+            watcher["config"] = {}
+        watchers.append(watcher)
+    return watchers
+
+
+def _persist_result(result: dict) -> None:
+    db_path = _db_path()
+    if not db_path.is_file():
+        return
+    conn = sqlite3.connect(str(db_path))
+    conn.execute(
+        """UPDATE state_watchers
+           SET last_health = ?, last_result = ?, last_checked_at = ?, updated_at = datetime('now')
+           WHERE watcher_id = ?""",
+        (
+            result["health"],
+            json.dumps(result, ensure_ascii=False),
+            result["checked_at"],
+            result["watcher_id"],
+        ),
+    )
+    conn.commit()
+    conn.close()
+
+
+def run_state_watchers(*, persist: bool = True, status: str = "active") -> dict:
+    watchers = _list_watchers(status=status)
+    results = [evaluate_state_watcher(watcher) for watcher in watchers]
+    counts = {"healthy": 0, "degraded": 0, "critical": 0, "unknown": 0}
+    for result in results:
+        counts[result["health"]] = counts.get(result["health"], 0) + 1
+        if persist:
+            _persist_result(result)
+    summary = {
+        "generated_at": _now_iso(),
+        "watcher_count": len(results),
+        "counts": counts,
+        "watchers": results,
+    }
+    if persist:
+        summary_file = _summary_file()
+        summary_file.parent.mkdir(parents=True, exist_ok=True)
+        summary_file.write_text(json.dumps(summary, indent=2, ensure_ascii=False))
+    return summary