nexo-brain 5.3.19 → 5.3.21

package/src/plugins/simple_api 2.py

@@ -0,0 +1,106 @@
+"""Minimal public API wrappers for the core NEXO mental model."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+
+import cognitive
+
+from plugins.episodic_memory import handle_recall
+from plugins.workflow import handle_workflow_open
+
+
+def handle_remember(
+    content: str,
+    title: str = "",
+    domain: str = "",
+    source_type: str = "note",
+    tags: str = "",
+    bypass_gate: bool = True,
+) -> str:
+    """Store one durable memory item with a single high-level call."""
+    clean_content = (content or "").strip()
+    if not clean_content:
+        return json.dumps({"ok": False, "error": "content is required"}, ensure_ascii=False, indent=2)
+
+    clean_title = (title or "").strip()[:120]
+    # Content fingerprint for deterministic dedup id — not security-sensitive.
+    source_id = hashlib.sha1(
+        f"{clean_title}|{clean_content}".encode("utf-8"), usedforsecurity=False
+    ).hexdigest()[:12]
+    memory_id = cognitive.ingest_to_ltm(
+        clean_content,
+        source_type=(source_type or "note").strip()[:40],
+        source_id=source_id,
+        source_title=clean_title or clean_content[:80],
+        domain=(domain or "").strip()[:120],
+        tags=(tags or "").strip()[:200],
+        bypass_gate=bool(bypass_gate),
+    )
+    return json.dumps(
+        {
+            "ok": bool(memory_id),
+            "memory_id": int(memory_id or 0),
+            "source_type": (source_type or "note").strip()[:40],
+            "title": clean_title or clean_content[:80],
+            "domain": (domain or "").strip()[:120],
+        },
+        ensure_ascii=False,
+        indent=2,
+    )
+
+
+def handle_memory_recall(query: str, days: int = 30) -> str:
+    """High-level memory lookup wrapper around nexo_recall."""
+    return handle_recall((query or "").strip(), days=max(1, int(days or 30)))
+
+
+def handle_consolidate(
+    max_insights: int = 12,
+    threshold: float = 0.9,
+    dry_run: bool = False,
+) -> str:
+    """Run the core memory consolidation cycle explicitly."""
+    promoted = cognitive.promote_stm_to_ltm()
+    quarantine = cognitive.process_quarantine()
+    dreamed = cognitive.dream_cycle(max_insights=max(1, int(max_insights or 12)))
+    semantic = cognitive.consolidate_semantic(threshold=float(threshold or 0.9), dry_run=bool(dry_run))
+    payload = {
+        "ok": True,
+        "promoted_to_ltm": int(promoted or 0),
+        "quarantine": quarantine,
+        "dream_cycle": dreamed,
+        "semantic_consolidation": semantic,
+        "dry_run": bool(dry_run),
+    }
+    return json.dumps(payload, ensure_ascii=False, indent=2)
+
+
+def handle_run_workflow(
+    sid: str,
+    goal: str,
+    steps: str = "[]",
+    goal_id: str = "",
+    shared_state: str = "{}",
+    owner: str = "",
+    idempotency_key: str = "",
+) -> str:
+    """Open a durable workflow with the public mental-model naming."""
+    return handle_workflow_open(
+        sid=sid,
+        goal=goal,
+        steps=steps,
+        goal_id=goal_id,
+        shared_state=shared_state,
+        owner=owner,
+        idempotency_key=idempotency_key,
+    )
+
+
+TOOLS = [
+    (handle_remember, "nexo_remember", "High-level memory write: store one durable memory item."),
+    (handle_memory_recall, "nexo_memory_recall", "High-level memory lookup wrapper around nexo_recall."),
+    (handle_consolidate, "nexo_consolidate", "Run NEXO memory consolidation explicitly: promote, process quarantine, dream, consolidate."),
+    (handle_run_workflow, "nexo_run_workflow", "High-level durable workflow entry point for the public API surface."),
+]

package/src/plugins/skills 2.py

@@ -0,0 +1,341 @@
+"""Skills plugin — reusable procedures, executable skills, and feedback loops."""
+
+from __future__ import annotations
+
+import json
+
+from db import (
+    create_skill,
+    delete_skill,
+    get_skill,
+    get_skill_stats,
+    list_skills,
+    match_skills,
+    merge_skills,
+    record_skill_usage,
+    search_skills,
+    update_skill,
+)
+from skills_runtime import (
+    apply_skill,
+    approve_skill_execution,
+    compose_skills,
+    detect_skill_coactivation_candidates,
+    get_featured_skill_summaries,
+    list_evolution_candidates,
+    materialize_outcome_pattern_skill,
+    promote_skill,
+    review_skill_outcomes,
+    retire_skill,
+    sync_skills,
+    test_skill,
+)
+
+
+def handle_skill_create(
+    id: str,
+    name: str,
+    description: str = "",
+    level: str = "draft",
+    tags: str = "[]",
+    trigger_patterns: str = "[]",
+    source_sessions: str = "[]",
+    linked_learnings: str = "[]",
+    file_path: str = "",
+    mode: str = "",
+    source_kind: str = "personal",
+    execution_level: str = "none",
+    approval_required: bool = False,
+    params_schema: str = "{}",
+    command_template: str = "{}",
+    executable_entry: str = "",
+) -> str:
+    if not id.startswith("SK-"):
+        return "ERROR: Skill ID must start with 'SK-' (e.g., SK-DEPLOY-CHROME-EXT)"
+    if get_skill(id):
+        return f"ERROR: Skill {id} already exists. Use nexo_skill_update to modify."
+
+    result = create_skill(
+        skill_id=id,
+        name=name,
+        description=description,
+        level=level,
+        tags=tags,
+        trigger_patterns=trigger_patterns,
+        source_sessions=source_sessions,
+        linked_learnings=linked_learnings,
+        file_path=file_path,
+        mode=mode,
+        source_kind=source_kind,
+        execution_level=execution_level,
+        approval_required=approval_required,
+        params_schema=params_schema,
+        command_template=command_template,
+        executable_entry=executable_entry,
+    )
+    if "error" in result:
+        return f"ERROR: {result['error']}"
+
+    return (
+        f"Skill {id} created ({result['level']}, {result.get('mode', 'guide')}, trust={result.get('trust_score', 50)}).\n"
+        f"  Name: {name}\n"
+        f"  Source: {result.get('source_kind', source_kind)}\n"
+        f"  Execution: {result.get('execution_level', execution_level)}"
+    )
+
+
+def handle_skill_match(task: str, level: str = "") -> str:
+    matches = match_skills(task, level=level)
+    if not matches:
+        return f"No skills found for: '{task}'"
+
+    lines = [f"SKILLS MATCHED ({len(matches)}) for '{task}':"]
+    for match in matches:
+        match_method = match.pop("_match", "unknown")
+        lines.append(
+            f"  [{match['id']}] {match['name']} ({match['level']}, {match.get('mode', 'guide')}, "
+            f"{match.get('source_kind', 'personal')}, trust={match['trust_score']}, used={match['use_count']}x) "
+            f"via {match_method}"
+        )
+        lines.append(f"    {match['description'][:140]}")
+    return "\n".join(lines)
+
+
+def handle_skill_get(id: str) -> str:
+    skill = get_skill(id)
+    if not skill:
+        return f"ERROR: Skill {id} not found."
+
+    lines = [
+        f"SKILL: {skill['id']}",
+        f"  Name: {skill['name']}",
+        f"  Description: {skill['description']}",
+        f"  Level: {skill['level']}",
+        f"  Mode: {skill.get('mode', 'guide')}",
+        f"  Source: {skill.get('source_kind', 'personal')}",
+        f"  Trust: {skill['trust_score']}",
+        f"  Execution level: {skill.get('execution_level', 'none')}",
+        f"  Approval required: {bool(skill.get('approval_required', 0))}",
+        f"  Approved at: {skill.get('approved_at') or 'no'}",
+        f"  Definition: {skill.get('definition_path') or '(none)'}",
+        f"  File: {skill.get('file_path') or '(none)'}",
+        f"  Params schema: {skill.get('params_schema', '{}')}",
+        f"  Triggers: {skill['trigger_patterns']}",
+        f"  Stats: {skill['use_count']} uses, {skill['success_count']} success, {skill['fail_count']} fail",
+    ]
+    return "\n".join(lines)
+
+
+def handle_skill_result(id: str, success: bool = True, context: str = "", notes: str = "") -> str:
+    result = record_skill_usage(skill_id=id, success=success, context=context, notes=notes)
+    if "error" in result:
+        return f"ERROR: {result['error']}"
+
+    promotion = result.get("_promotion")
+    msg = f"Skill {id} usage recorded: {'SUCCESS' if success else 'FAILURE'} (trust={result['trust_score']})"
+    if promotion:
+        msg += f"\n  ⚡ PROMOTION: {promotion}"
+    return msg
+
+
+def handle_skill_list(level: str = "", tag: str = "", source_kind: str = "") -> str:
+    skills = list_skills(level=level, tag=tag, source_kind=source_kind)
+    if not skills:
+        return "No skills found."
+
+    lines = [f"SKILLS ({len(skills)}):"]
+    for skill in skills:
+        lines.append(
+            f"  [{skill['id']}] {skill['name']} ({skill['level']}, {skill.get('mode', 'guide')}, "
+            f"{skill.get('source_kind', 'personal')}, trust={skill['trust_score']}, used={skill['use_count']}x)"
+        )
+    return "\n".join(lines)
+
+
+def handle_skill_merge(id1: str, id2: str, keep_id: str = "") -> str:
+    result = merge_skills(id1, id2, keep_id=keep_id)
+    if "error" in result:
+        return f"ERROR: {result['error']}"
+    return (
+        f"Skills merged. Kept {result['id']}, deleted {result['_merged_from']}.\n"
+        f"  Trust: {result['trust_score']}, Uses: {result['use_count']}"
+    )
+
+
+def handle_skill_stats() -> str:
+    stats = get_skill_stats()
+    return (
+        "SKILL STATS:\n"
+        f"  Total: {stats['total']}\n"
+        f"  By level: {', '.join(f'{k}={v}' for k, v in sorted(stats['by_level'].items()))}\n"
+        f"  Avg trust: {stats['avg_trust']}\n"
+        f"  Total uses: {stats['total_uses']} (success rate: {stats['success_rate']}%)\n"
+        f"  Uses last 7d: {stats['uses_last_7d']}\n"
+        f"  Reuse rate: {stats['skill_reuse_rate']}\n"
+        f"  Outcome-backed skills: {stats['outcome_backed_skills']} (avg success: {stats['outcome_backed_success_rate']}%)\n"
+        f"  Promoted from evidence: {stats['promoted_from_evidence_count']}\n"
+        f"  Retired for poor outcomes: {stats['retired_for_poor_outcomes_count']}"
+    )
+
+
+def handle_skill_apply(id: str, params: str = "{}", mode: str = "auto", dry_run: bool = False, context: str = "") -> str:
+    return json.dumps(apply_skill(id, params=params, mode=mode, dry_run=dry_run, context=context), ensure_ascii=False)
+
+
+def handle_skill_test(id: str, params: str = "{}", mode: str = "auto", context: str = "") -> str:
+    return json.dumps(test_skill(id, params=params, mode=mode, context=context), ensure_ascii=False)
+
+
+def handle_skill_approve(id: str, execution_level: str = "", approved_by: str = "") -> str:
+    result = approve_skill_execution(id, execution_level=execution_level, approved_by=approved_by)
+    if "error" in result:
+        return f"ERROR: {result['error']}"
+    return (
+        f"Skill {id} approved.\n"
+        f"  Execution level: {result.get('execution_level', 'none')}\n"
+        f"  Approved at: {result.get('approved_at', '')}\n"
+        f"  Approved by: {result.get('approved_by', '')}"
+    )
+
+
+def handle_skill_sync() -> str:
+    result = sync_skills()
+    return json.dumps(result, ensure_ascii=False)
+
+
+def handle_skill_featured(limit: int = 5) -> str:
+    return json.dumps(get_featured_skill_summaries(limit=limit), ensure_ascii=False)
+
+
+def handle_skill_evolution_candidates() -> str:
+    return json.dumps(list_evolution_candidates(), ensure_ascii=False)
+
+
+def handle_skill_compose_candidates(
+    min_co_occurrence: int = 3,
+    min_success_rate: float = 0.6,
+    limit: int = 20,
+) -> str:
+    """List Voyager-style composition candidates from skill_usage co-activation.
+
+    Closes Fase 5 item 5. Detects pairs of skills that fire together
+    in the same session repeatedly and could become a single composite.
+    Returns the candidates sorted by co-occurrence count, with a
+    suggested deterministic skill_id (SK-COMPOSE-<a>+<b>) that
+    nexo_skill_compose can take as input.
+
+    Args:
+        min_co_occurrence: minimum sessions where both skills fired (default 3).
+        min_success_rate: minimum joint success rate (default 0.6).
+        limit: max candidates to return (default 20).
+    """
+    return json.dumps(
+        detect_skill_coactivation_candidates(
+            min_co_occurrence=int(min_co_occurrence),
+            min_success_rate=float(min_success_rate),
+            limit=int(limit),
+        ),
+        ensure_ascii=False,
+        indent=2,
+    )
+
+
+def handle_skill_seed_from_outcome_pattern(pattern_key: str) -> str:
+    return json.dumps(materialize_outcome_pattern_skill(pattern_key), ensure_ascii=False)
+
+
+def handle_skill_outcome_review(id: str, auto_apply: bool = False) -> str:
+    return json.dumps(review_skill_outcomes(id, auto_apply=auto_apply), ensure_ascii=False)
+
+
+def handle_skill_promote(id: str, target_level: str = "published", reason: str = "") -> str:
+    return json.dumps(promote_skill(id, target_level=target_level, reason=reason), ensure_ascii=False)
+
+
+def handle_skill_retire(id: str, replacement_id: str = "", reason: str = "") -> str:
+    return json.dumps(retire_skill(id, replacement_id=replacement_id, reason=reason), ensure_ascii=False)
+
+
+def handle_skill_compose(
+    new_id: str,
+    name: str,
+    component_ids: str = "[]",
+    description: str = "",
+    level: str = "draft",
+    mode: str = "guide",
+    tags: str = "[]",
+    trigger_patterns: str = "[]",
+) -> str:
+    try:
+        component_list = json.loads(component_ids) if str(component_ids or "").strip().startswith("[") else [
+            item.strip() for item in str(component_ids or "").split(",") if item.strip()
+        ]
+    except json.JSONDecodeError:
+        component_list = []
+    try:
+        tags_list = json.loads(tags) if str(tags or "").strip().startswith("[") else [
+            item.strip() for item in str(tags or "").split(",") if item.strip()
+        ]
+    except json.JSONDecodeError:
+        tags_list = []
+    try:
+        trigger_list = json.loads(trigger_patterns) if str(trigger_patterns or "").strip().startswith("[") else [
+            item.strip() for item in str(trigger_patterns or "").split(",") if item.strip()
+        ]
+    except json.JSONDecodeError:
+        trigger_list = []
+    return json.dumps(
+        compose_skills(
+            new_skill_id=new_id,
+            name=name,
+            component_ids=component_list,
+            description=description,
+            level=level,
+            mode=mode,
+            tags=tags_list,
+            trigger_patterns=trigger_list,
+        ),
+        ensure_ascii=False,
+    )
+
+
+TOOLS = [
+    (handle_skill_create, "nexo_skill_create",
+     "Create a new skill with guide/execute/hybrid metadata, triggers, params schema, and execution level."),
+    (handle_skill_match, "nexo_skill_match",
+     "Find skills matching a task description. Call before multi-step tasks."),
+    (handle_skill_get, "nexo_skill_get",
+     "Get a skill's full details, including execution metadata and approval state."),
+    (handle_skill_result, "nexo_skill_result",
+     "Record the result of using a skill. Updates trust and promotions."),
+    (handle_skill_list, "nexo_skill_list",
+     "List skills, optionally filtered by level, tag, or source kind."),
+    (handle_skill_merge, "nexo_skill_merge",
+     "Merge two similar skills into one."),
+    (handle_skill_stats, "nexo_skill_stats",
+     "Show aggregate skill statistics."),
+    (handle_skill_apply, "nexo_skill_apply",
+     "Apply a skill in guide, execute, or hybrid mode. Execution goes through the stable nexo scripts runtime."),
+    (handle_skill_test, "nexo_skill_test",
+     "Test a skill through the canonical runtime in dry-run mode before wider use."),
+    (handle_skill_approve, "nexo_skill_approve",
+     "Approve a local/remote executable skill so it can run."),
+    (handle_skill_sync, "nexo_skill_sync",
+     "Sync filesystem skill definitions from personal/core/community directories into SQLite."),
+    (handle_skill_featured, "nexo_skill_featured",
+     "Return featured published/stable skills for startup discovery."),
+    (handle_skill_evolution_candidates, "nexo_skill_evolution_candidates",
+     "Return candidates for skill improvement or text-to-script evolution."),
+    (handle_skill_seed_from_outcome_pattern, "nexo_skill_seed_from_outcome_pattern",
+     "Materialize a draft skill candidate from a repeated successful outcome pattern with linked evidence."),
+    (handle_skill_outcome_review, "nexo_skill_outcome_review",
+     "Review whether a skill should be promoted, deprioritized, or retired based on sustained outcome evidence."),
+    (handle_skill_promote, "nexo_skill_promote",
+     "Promote a skill to a stronger published/stable lifecycle stage."),
+    (handle_skill_retire, "nexo_skill_retire",
+     "Retire a skill cleanly so it leaves the active lifecycle."),
+    (handle_skill_compose, "nexo_skill_compose",
+     "Compose multiple existing skills into one higher-level reusable skill."),
+    (handle_skill_compose_candidates, "nexo_skill_compose_candidates",
+     "Voyager-style detection: list skill pairs that fired together in 3+ sessions with 60%+ joint success and could become a single composite (closes Fase 5 item 5)."),
+]

package/src/plugins/state_watchers 2.py

@@ -0,0 +1,79 @@
+"""State watchers plugin — persistent drift/health/expiry watchers."""
+
+from __future__ import annotations
+
+import json
+
+from db import create_state_watcher, list_state_watchers, update_state_watcher
+from state_watchers_runtime import run_state_watchers
+
+
+def handle_state_watcher_create(
+    watcher_type: str,
+    title: str,
+    target: str = "",
+    severity: str = "warn",
+    status: str = "active",
+    config: str = "{}",
+) -> str:
+    """Create a persistent state watcher for drift, health, or expiry."""
+    try:
+        watcher = create_state_watcher(
+            watcher_type,
+            title,
+            target=target,
+            severity=severity,
+            status=status,
+            config=json.loads(config) if str(config).strip() else {},
+        )
+    except (ValueError, json.JSONDecodeError) as exc:
+        return json.dumps({"ok": False, "error": str(exc)}, ensure_ascii=False, indent=2)
+    return json.dumps({"ok": True, "watcher": watcher}, ensure_ascii=False, indent=2)
+
+
+def handle_state_watcher_update(
+    watcher_id: str,
+    title: str = "",
+    target: str = "",
+    severity: str = "",
+    status: str = "",
+    config: str = "",
+) -> str:
+    """Update an existing state watcher."""
+    payload = None
+    if str(config).strip():
+        try:
+            payload = json.loads(config)
+        except json.JSONDecodeError as exc:
+            return json.dumps({"ok": False, "error": str(exc)}, ensure_ascii=False, indent=2)
+    watcher = update_state_watcher(
+        watcher_id,
+        title=(title or None),
+        target=(target or None),
+        severity=(severity or None),
+        status=(status or None),
+        config=payload,
+    )
+    if not watcher:
+        return json.dumps({"ok": False, "error": f"Unknown watcher_id: {watcher_id}"}, ensure_ascii=False, indent=2)
+    return json.dumps({"ok": True, "watcher": watcher}, ensure_ascii=False, indent=2)
+
+
+def handle_state_watcher_list(status: str = "", watcher_type: str = "", limit: int = 50) -> str:
+    """List configured state watchers."""
+    watchers = list_state_watchers(status=status, watcher_type=watcher_type, limit=max(1, int(limit or 50)))
+    return json.dumps({"ok": True, "count": len(watchers), "watchers": watchers}, ensure_ascii=False, indent=2)
+
+
+def handle_state_watcher_run(status: str = "active", persist: bool = True) -> str:
+    """Run active state watchers and return their current health."""
+    summary = run_state_watchers(status=status or "active", persist=bool(persist))
+    return json.dumps({"ok": True, **summary}, ensure_ascii=False, indent=2)
+
+
+TOOLS = [
+    (handle_state_watcher_create, "nexo_state_watcher_create", "Create a persistent state watcher for repo drift, cron drift, API health, environment drift, or expiry."),
+    (handle_state_watcher_update, "nexo_state_watcher_update", "Update an existing persistent state watcher."),
+    (handle_state_watcher_list, "nexo_state_watcher_list", "List persistent state watchers."),
+    (handle_state_watcher_run, "nexo_state_watcher_run", "Run persistent state watchers and return their current health summary."),
+]