nexo-brain 2.2.0 → 2.3.0

package/src/plugins/episodic_memory.py

@@ -166,7 +166,8 @@ def handle_session_diary_write(decisions: str, summary: str,
                                 user_signals: str = '',
                                 domain: str = '',
                                 session_id: str = '',
-                                self_critique: str = '') -> str:
+                                self_critique: str = '',
+                                source: str = 'claude') -> str:
     """Write session diary entry at end of session. OBLIGATORIO antes de cerrar.
 
     Args:
@@ -179,13 +180,14 @@ def handle_session_diary_write(decisions: str, summary: str,
         user_signals: Observable signals from user during session — response speed (fast='s' vs detailed explanations), tone (direct, frustrated, exploratory, excited), corrections given, topics he initiated vs topics NEXO initiated. Factual observations only, not interpretations.
         domain: Project context: ecommerce, project-a, nexo, project-b, server, other
         session_id: Current session ID
-        self_critique: REQUIRED. Honest post-mortem: What should I have done proactively? Did user have to ask me something I should have detected? Did I repeat known errors? What concrete rule would prevent repetition? If clean session: 'No self-critique — clean session.'
+        self_critique: REQUIRED. Honest post-mortem.
+        source: Session type. 'claude' for human-interactive sessions (default), 'cron' for automated cron jobs. Affects visibility at startup.
     """
     sid = session_id or 'unknown'
     # Clean up draft — manual diary supersedes it
     from db import delete_diary_draft
     delete_diary_draft(sid)
-    result = write_session_diary(sid, decisions, summary, discarded, pending, context_next, mental_state, domain=domain, user_signals=user_signals, self_critique=self_critique)
+    result = write_session_diary(sid, decisions, summary, discarded, pending, context_next, mental_state, domain=domain, user_signals=user_signals, self_critique=self_critique, source=source)
     if "error" in result:
         return f"ERROR: {result['error']}"
     _cognitive_ingest_safe(summary, "diary", f"diary#{result.get('id','')}", f"Session {sid} summary", domain)

package/src/plugins/schedule.py

@@ -0,0 +1,212 @@
+"""NEXO Schedule — Cron execution history, status, and management tools."""
+
+import json
+import os
+import platform
+import subprocess
+from pathlib import Path
+
+from db import cron_runs_recent, cron_runs_summary
+
+
+def handle_schedule_status(hours: int = 24, cron_id: str = '') -> str:
+    """Show cron execution status — what ran, what failed, durations.
+
+    Args:
+        hours: How far back to look (default 24h).
+        cron_id: Filter to a specific cron (optional). E.g. 'deep-sleep', 'immune'.
+    """
+    if cron_id:
+        runs = cron_runs_recent(hours, cron_id)
+        if not runs:
+            return f"No runs for '{cron_id}' in the last {hours}h."
+        lines = [f"CRON RUNS — {cron_id} (last {hours}h): {len(runs)} executions"]
+        for r in runs:
+            status = "✅" if r.get("exit_code") == 0 else "❌"
+            dur = f"{r['duration_secs']:.0f}s" if r.get("duration_secs") else "running"
+            summary = f" — {r['summary'][:100]}" if r.get("summary") else ""
+            error = f" ERROR: {r['error'][:100]}" if r.get("error") else ""
+            lines.append(f"  {status} {r['started_at']} ({dur}){summary}{error}")
+        return "\n".join(lines)
+
+    # Summary view — one line per cron
+    summary = cron_runs_summary(hours)
+    if not summary:
+        return f"No cron executions recorded in the last {hours}h."
+
+    lines = [f"CRON STATUS (last {hours}h):"]
+    for s in summary:
+        status = "✅" if s.get("last_exit_code") == 0 else "❌"
+        rate = f"{s['succeeded']}/{s['total_runs']}"
+        dur = f"{s['avg_duration']:.0f}s avg" if s.get("avg_duration") else ""
+        summary_txt = f" — {s['last_summary'][:80]}" if s.get("last_summary") else ""
+        lines.append(f"  {status} {s['cron_id']}: {rate} OK, {dur}{summary_txt}")
+
+    return "\n".join(lines)
+
+
+def handle_schedule_add(cron_id: str, script: str, schedule: str = '',
+                        interval_seconds: int = 0, description: str = '',
+                        script_type: str = 'python') -> str:
+    """Add a new personal cron job. Generates and installs the LaunchAgent (macOS) or systemd timer (Linux).
+
+    Args:
+        cron_id: Unique ID for this cron (e.g. 'my-backup', 'report-daily'). Must be lowercase with hyphens.
+        script: Path to the script to run (absolute or relative to NEXO_HOME/scripts/).
+        schedule: Time-based schedule as 'HH:MM' (daily) or 'HH:MM:weekday' (e.g. '08:00:1' for Monday 8AM). Mutually exclusive with interval_seconds.
+        interval_seconds: Run every N seconds (e.g. 300 for every 5 min). Mutually exclusive with schedule.
+        description: What this cron does (for logs and status).
+        script_type: 'python' (default) or 'shell'.
+    """
+    if not cron_id or not script:
+        return "ERROR: cron_id and script are required."
+    if not schedule and not interval_seconds:
+        return "ERROR: either schedule (e.g. '08:00') or interval_seconds (e.g. 300) is required."
+
+    nexo_home = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+    script_path = Path(script)
+    if not script_path.is_absolute():
+        script_path = nexo_home / "scripts" / script
+    if not script_path.exists():
+        return f"ERROR: script not found: {script_path}"
+
+    wrapper_path = nexo_home / "scripts" / "nexo-cron-wrapper.sh"
+    if not wrapper_path.exists():
+        return f"ERROR: wrapper not found at {wrapper_path}. Run crons/sync.py first."
+
+    system = platform.system()
+
+    if system == "Darwin":
+        return _add_launchagent(cron_id, str(script_path), str(wrapper_path),
+                                schedule, interval_seconds, description, script_type, nexo_home)
+    elif system == "Linux":
+        return _add_systemd_timer(cron_id, str(script_path), str(wrapper_path),
+                                  schedule, interval_seconds, description, script_type, nexo_home)
+    else:
+        return f"ERROR: unsupported platform: {system}"
+
+
+def _add_launchagent(cron_id, script_path, wrapper_path, schedule, interval_seconds,
+                     description, script_type, nexo_home):
+    """Create and load a macOS LaunchAgent."""
+    import plistlib
+
+    label = f"com.nexo.{cron_id}"
+    plist_path = Path.home() / "Library" / "LaunchAgents" / f"{label}.plist"
+
+    if plist_path.exists():
+        return f"ERROR: cron '{cron_id}' already exists at {plist_path}. Use a different ID or remove it first."
+
+    python_bin = "/opt/homebrew/bin/python3"
+    for p in ["/opt/homebrew/bin/python3", "/usr/local/bin/python3", "/usr/bin/python3"]:
+        if Path(p).exists():
+            python_bin = p
+            break
+
+    if script_type == "shell":
+        program_args = ["/bin/bash", wrapper_path, cron_id, "/bin/bash", script_path]
+    else:
+        program_args = ["/bin/bash", wrapper_path, cron_id, python_bin, script_path]
+
+    plist = {
+        "Label": label,
+        "ProgramArguments": program_args,
+        "StandardOutPath": str(nexo_home / "logs" / f"{cron_id}-stdout.log"),
+        "StandardErrorPath": str(nexo_home / "logs" / f"{cron_id}-stderr.log"),
+        "EnvironmentVariables": {
+            "HOME": str(Path.home()),
+            "NEXO_HOME": str(nexo_home),
+            "PATH": "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:" + str(Path.home() / ".local/bin"),
+        },
+    }
+
+    if interval_seconds:
+        plist["StartInterval"] = interval_seconds
+    elif schedule:
+        parts = schedule.split(":")
+        cal = {"Hour": int(parts[0]), "Minute": int(parts[1])}
+        if len(parts) > 2:
+            cal["Weekday"] = int(parts[2])
+        plist["StartCalendarInterval"] = cal
+
+    with open(plist_path, "wb") as f:
+        plistlib.dump(plist, f)
+
+    subprocess.run(["launchctl", "bootstrap", f"gui/{os.getuid()}", str(plist_path)], capture_output=True)
+
+    return f"Cron '{cron_id}' installed at {plist_path} and loaded.{' Schedule: ' + schedule if schedule else f' Interval: {interval_seconds}s'}"
+
+
+def _add_systemd_timer(cron_id, script_path, wrapper_path, schedule, interval_seconds,
+                       description, script_type, nexo_home):
+    """Create and enable a systemd user timer (Linux)."""
+    unit_dir = Path.home() / ".config" / "systemd" / "user"
+    unit_dir.mkdir(parents=True, exist_ok=True)
+
+    python_bin = "/usr/bin/python3"
+    for p in ["/usr/bin/python3", "/usr/local/bin/python3"]:
+        if Path(p).exists():
+            python_bin = p
+            break
+
+    if script_type == "shell":
+        exec_cmd = f"/bin/bash {wrapper_path} {cron_id} /bin/bash {script_path}"
+    else:
+        exec_cmd = f"/bin/bash {wrapper_path} {cron_id} {python_bin} {script_path}"
+
+    # Service unit
+    service_content = f"""[Unit]
+Description=NEXO: {description or cron_id}
+
+[Service]
+Type=oneshot
+ExecStart={exec_cmd}
+Environment=NEXO_HOME={nexo_home}
+Environment=HOME={Path.home()}
+"""
+    service_path = unit_dir / f"nexo-{cron_id}.service"
+    service_path.write_text(service_content)
+
+    # Timer unit
+    if interval_seconds:
+        timer_spec = f"OnUnitActiveSec={interval_seconds}s\nOnBootSec=60s"
+    elif schedule:
+        parts = schedule.split(":")
+        hour, minute = int(parts[0]), int(parts[1])
+        if len(parts) > 2:
+            days = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
+            day = days[int(parts[2])]
+            timer_spec = f"OnCalendar={day} *-*-* {hour:02d}:{minute:02d}:00"
+        else:
+            timer_spec = f"OnCalendar=*-*-* {hour:02d}:{minute:02d}:00"
+    else:
+        return "ERROR: no schedule or interval"
+
+    timer_content = f"""[Unit]
+Description=NEXO timer: {description or cron_id}
+
+[Timer]
+{timer_spec}
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+"""
+    timer_path = unit_dir / f"nexo-{cron_id}.timer"
+    timer_path.write_text(timer_content)
+
+    subprocess.run(["systemctl", "--user", "daemon-reload"], capture_output=True)
+    subprocess.run(["systemctl", "--user", "enable", "--now", f"nexo-{cron_id}.timer"], capture_output=True)
+
+    return f"Cron '{cron_id}' installed as systemd timer and enabled. Service: {service_path}, Timer: {timer_path}"
+
+
+TOOLS = [
+    (handle_schedule_status, "nexo_schedule_status",
+     "Show cron execution status: what ran overnight, what failed, durations. "
+     "Use at startup to give the user a quick health overview of autonomous processes."),
+
+    (handle_schedule_add, "nexo_schedule_add",
+     "Add a new personal cron job. Creates LaunchAgent (macOS) or systemd timer (Linux) "
+     "automatically, wrapped with execution tracking."),
+]

package/src/plugins/skills.py

@@ -0,0 +1,264 @@
+"""Skills plugin — reusable procedures extracted from complex tasks.
+
+Skills are procedural knowledge (step-by-step how-tos) vs learnings which are
+declarative (don't do X). Created automatically by Deep Sleep or manually.
+
+Pipeline: trace → draft → published, fully autonomous.
+Trust score with decay controls quality — no human approval gates.
+"""
+
+import json
+from db import (
+    create_skill, get_skill, list_skills, search_skills,
+    update_skill, delete_skill,
+    record_skill_usage, match_skills, merge_skills, get_skill_stats,
+)
+
+
+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 = '',
+) -> str:
+    """Create a new skill (reusable procedure).
+
+    Skills are procedural knowledge — step-by-step instructions for complex tasks.
+    Created by Deep Sleep (auto-extraction) or manually during sessions.
+
+    Pipeline levels: trace → draft → published → archived.
+    Promotion is automatic: 2+ successful uses in distinct contexts → published.
+
+    Args:
+        id: Unique ID starting with 'SK-' (e.g., SK-DEPLOY-CHROME-EXT).
+        name: Human-readable name (e.g., 'Deploy Chrome Extension').
+        description: What this skill does (1-2 sentences).
+        level: Starting level — trace, draft (default), published, archived.
+        tags: JSON array of tags for discovery (e.g., '["chrome", "extension", "deploy"]').
+        trigger_patterns: JSON array of phrases that should trigger this skill
+                         (e.g., '["deploy extension", "publish chrome"]').
+        source_sessions: JSON array of diary IDs where this skill was observed.
+        linked_learnings: JSON array of learning IDs related to this skill.
+        file_path: Path to the .md file with full procedure (if stored as file).
+    """
+    if not id.startswith('SK-'):
+        return "ERROR: Skill ID must start with 'SK-' (e.g., SK-DEPLOY-CHROME-EXT)"
+
+    existing = get_skill(id)
+    if existing:
+        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,
+    )
+    if "error" in result:
+        return f"ERROR: {result['error']}"
+
+    return (
+        f"Skill {id} created ({level}, trust={result.get('trust_score', 50)}).\n"
+        f"  Name: {name}\n"
+        f"  Tags: {tags}\n"
+        f"  Triggers: {trigger_patterns}"
+    )
+
+
+def handle_skill_match(task: str, level: str = '') -> str:
+    """Find skills matching a task description. Call BEFORE starting multi-step tasks.
+
+    Searches by: FTS5 relevance, trigger pattern matching, tag keyword overlap.
+    Returns top-3 matches sorted by trust score.
+
+    Args:
+        task: Description of what you're about to do (e.g., 'deploy chrome extension to CWS').
+        level: Filter by level (optional). Default: draft + published.
+    """
+    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 m in matches:
+        match_method = m.pop('_match', 'unknown')
+        fp = f" → {m['file_path']}" if m.get('file_path') else ""
+        lines.append(
+            f"  [{m['id']}] {m['name']} ({m['level']}, trust={m['trust_score']}, "
+            f"used={m['use_count']}x) via {match_method}{fp}\n"
+            f"    {m['description'][:120]}"
+        )
+        try:
+            triggers = json.loads(m.get('trigger_patterns', '[]'))
+            if triggers:
+                lines.append(f"    Triggers: {', '.join(triggers[:5])}")
+        except (json.JSONDecodeError, TypeError):
+            pass
+    return "\n".join(lines)
+
+
+def handle_skill_get(id: str) -> str:
+    """Get a skill's full details including usage history.
+
+    Args:
+        id: Skill ID (e.g., SK-DEPLOY-CHROME-EXT).
+    """
+    skill = get_skill(id)
+    if not skill:
+        return f"ERROR: Skill {id} not found."
+
+    from db import get_db
+    conn = get_db()
+    recent_uses = conn.execute(
+        "SELECT * FROM skill_usage WHERE skill_id = ? ORDER BY created_at DESC LIMIT 5",
+        (id,),
+    ).fetchall()
+
+    lines = [
+        f"SKILL: {skill['id']}",
+        f"  Name: {skill['name']}",
+        f"  Description: {skill['description']}",
+        f"  Level: {skill['level']}",
+        f"  Trust: {skill['trust_score']}",
+        f"  File: {skill['file_path'] or '(none)'}",
+        f"  Tags: {skill['tags']}",
+        f"  Triggers: {skill['trigger_patterns']}",
+        f"  Source sessions: {skill['source_sessions']}",
+        f"  Linked learnings: {skill['linked_learnings']}",
+        f"  Stats: {skill['use_count']} uses, {skill['success_count']} success, {skill['fail_count']} fail",
+        f"  Created: {skill['created_at']}",
+        f"  Last used: {skill['last_used_at'] or 'never'}",
+    ]
+
+    if recent_uses:
+        lines.append("\n  RECENT USAGE:")
+        for u in recent_uses:
+            u = dict(u)
+            status = "✓" if u['success'] else "✗"
+            lines.append(f"    {status} {u['created_at']} — {u['context'][:60] or '(no context)'}")
+            if u.get('notes'):
+                lines.append(f"      Notes: {u['notes'][:80]}")
+
+    return "\n".join(lines)
+
+
+def handle_skill_result(id: str, success: bool = True, context: str = '', notes: str = '') -> str:
+    """Record the result of using a skill. Auto-promotes/degrades based on trust rules.
+
+    Call this AFTER following a skill's procedure to record whether it worked.
+    - Success: trust +5. After 2+ successes in distinct contexts: draft → published.
+    - Failure: trust -10. If trust < 20: → archived.
+
+    Args:
+        id: Skill ID.
+        success: Whether the skill's procedure worked correctly.
+        context: What task you were doing (used for distinct-context promotion).
+        notes: Additional notes (especially useful for failures — what went wrong).
+    """
+    result = record_skill_usage(skill_id=id, success=success, context=context, notes=notes)
+    if "error" in result:
+        return f"ERROR: {result['error']}"
+
+    promotion = result.pop('_promotion', None)
+    status = "SUCCESS" if success else "FAILURE"
+    msg = f"Skill {id} usage recorded: {status} (trust={result['trust_score']})"
+    if promotion:
+        msg += f"\n  ⚡ PROMOTION: {promotion}"
+    return msg
+
+
+def handle_skill_list(level: str = '', tag: str = '') -> str:
+    """List all skills, optionally filtered by level or tag.
+
+    Args:
+        level: Filter by level — trace, draft, published, archived.
+        tag: Filter by tag (e.g., 'chrome', 'deploy', 'shopify').
+    """
+    skills = list_skills(level=level, tag=tag)
+    if not skills:
+        filters = []
+        if level: filters.append(f"level={level}")
+        if tag: filters.append(f"tag={tag}")
+        return f"No skills found{' (' + ', '.join(filters) + ')' if filters else ''}."
+
+    lines = [f"SKILLS ({len(skills)}):"]
+    for s in skills:
+        fp = f" → {s['file_path']}" if s.get('file_path') else ""
+        used = f", last={s['last_used_at'][:10]}" if s.get('last_used_at') else ""
+        lines.append(
+            f"  [{s['id']}] {s['name']} ({s['level']}, trust={s['trust_score']}, "
+            f"used={s['use_count']}x{used}){fp}"
+        )
+    return "\n".join(lines)
+
+
+def handle_skill_merge(id1: str, id2: str, keep_id: str = '') -> str:
+    """Merge two similar skills into one. Combines tags, triggers, usage history.
+
+    The survivor keeps the higher trust score and all combined metadata.
+    The donor is deleted.
+
+    Args:
+        id1: First skill ID.
+        id2: Second skill ID.
+        keep_id: Which one to keep (default: higher trust score).
+    """
+    result = merge_skills(id1, id2, keep_id=keep_id)
+    if "error" in result:
+        return f"ERROR: {result['error']}"
+
+    merged_from = result.pop('_merged_from', '?')
+    return (
+        f"Skills merged. Kept {result['id']}, deleted {merged_from}.\n"
+        f"  Trust: {result['trust_score']}, Uses: {result['use_count']}, "
+        f"Tags: {result['tags']}"
+    )
+
+
+def handle_skill_stats() -> str:
+    """Show aggregate skill statistics: total count, by level, avg trust, usage rates."""
+    stats = get_skill_stats()
+    levels = stats.get('by_level', {})
+    lines = [
+        "SKILL STATS:",
+        f"  Total: {stats['total']}",
+        f"  By level: {', '.join(f'{k}={v}' for k, v in sorted(levels.items()))}",
+        f"  Avg trust: {stats['avg_trust']}",
+        f"  Total uses: {stats['total_uses']} (success rate: {stats['success_rate']}%)",
+        f"  Uses last 7d: {stats['uses_last_7d']}",
+    ]
+    return "\n".join(lines)
+
+
+# Plugin registration — TOOLS array consumed by plugin_loader.py
+TOOLS = [
+    (handle_skill_create, "nexo_skill_create",
+     "Create a new skill (reusable procedure). Skills are step-by-step instructions for complex tasks. "
+     "Auto-promoted from draft→published after 2+ successful uses. ID must start with 'SK-'."),
+
+    (handle_skill_match, "nexo_skill_match",
+     "Find skills matching a task description. Call BEFORE starting multi-step tasks "
+     "to check if a reusable procedure exists. Returns top-3 matches by trust score."),
+
+    (handle_skill_get, "nexo_skill_get",
+     "Get a skill's full details including procedure, tags, triggers, and usage history."),
+
+    (handle_skill_result, "nexo_skill_result",
+     "Record the result of using a skill (success/failure). Auto-promotes draft→published "
+     "after 2+ successes, auto-archives if trust drops below 20."),
+
+    (handle_skill_list, "nexo_skill_list",
+     "List all skills, optionally filtered by level (trace/draft/published/archived) or tag."),
+
+    (handle_skill_merge, "nexo_skill_merge",
+     "Merge two similar skills into one. Combines tags, triggers, and usage history. "
+     "Survivor keeps the higher trust score."),
+
+    (handle_skill_stats, "nexo_skill_stats",
+     "Show aggregate skill statistics: count by level, average trust, usage rates."),
+]