nexo-brain 5.3.26 → 5.3.28

package/src/plugins/simple_api 2.py

@@ -1,106 +0,0 @@
-"""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

@@ -1,341 +0,0 @@
-"""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

@@ -1,79 +0,0 @@
-"""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."),
-]