nexo-brain 5.3.19 → 5.3.21

package/src/plugins/personal_scripts 2.py

@@ -0,0 +1,117 @@
+"""NEXO Personal Scripts — registry-backed management for user scripts."""
+
+import json
+
+from db import init_db, list_personal_scripts, list_personal_script_schedules
+from plugins.schedule import handle_schedule_add
+from script_registry import (
+    classify_scripts_dir,
+    create_script,
+    ensure_personal_schedules,
+    reconcile_personal_scripts,
+    remove_personal_script,
+    sync_personal_scripts,
+    unschedule_personal_script,
+)
+
+
+def handle_personal_scripts_sync() -> str:
+    init_db()
+    result = sync_personal_scripts()
+    return json.dumps(result, ensure_ascii=False)
+
+
+def handle_personal_scripts_classify() -> str:
+    return json.dumps(classify_scripts_dir(), ensure_ascii=False)
+
+
+def handle_personal_scripts_list(include_schedules: bool = True) -> str:
+    init_db()
+    sync_personal_scripts()
+    scripts = list_personal_scripts()
+    if include_schedules:
+        return json.dumps({"scripts": scripts}, ensure_ascii=False)
+
+    simplified = []
+    for script in scripts:
+        simplified.append({
+            "id": script["id"],
+            "name": script["name"],
+            "description": script.get("description", ""),
+            "runtime": script.get("runtime", "unknown"),
+            "path": script["path"],
+            "has_schedule": script.get("has_schedule", False),
+        })
+    return json.dumps({"scripts": simplified}, ensure_ascii=False)
+
+
+def handle_personal_script_create(
+    name: str,
+    description: str = "",
+    runtime: str = "python",
+    schedule: str = "",
+    interval_seconds: int = 0,
+) -> str:
+    init_db()
+    created = create_script(name, description=description, runtime=runtime)
+    if schedule or interval_seconds:
+        cron_id = created["name"]
+        handle_schedule_add(
+            cron_id=cron_id,
+            script=created["path"],
+            schedule=schedule,
+            interval_seconds=interval_seconds,
+            description=description,
+            script_type=runtime,
+        )
+        sync_result = sync_personal_scripts()
+        created["sync"] = sync_result
+    return json.dumps(created, ensure_ascii=False)
+
+
+def handle_personal_script_schedules() -> str:
+    init_db()
+    sync_personal_scripts()
+    return json.dumps({"schedules": list_personal_script_schedules()}, ensure_ascii=False)
+
+
+def handle_personal_scripts_reconcile(dry_run: bool = False) -> str:
+    init_db()
+    return json.dumps(reconcile_personal_scripts(dry_run=dry_run), ensure_ascii=False)
+
+
+def handle_personal_scripts_ensure_schedules(dry_run: bool = False) -> str:
+    init_db()
+    return json.dumps(ensure_personal_schedules(dry_run=dry_run), ensure_ascii=False)
+
+
+def handle_personal_script_unschedule(name: str) -> str:
+    init_db()
+    return json.dumps(unschedule_personal_script(name), ensure_ascii=False)
+
+
+def handle_personal_script_remove(name: str, keep_file: bool = False) -> str:
+    init_db()
+    return json.dumps(remove_personal_script(name, keep_file=keep_file), ensure_ascii=False)
+
+
+TOOLS = [
+    (handle_personal_scripts_sync, "nexo_personal_scripts_sync",
+     "Sync personal scripts and personal cron schedules from filesystem and LaunchAgents into the registry."),
+    (handle_personal_scripts_classify, "nexo_personal_scripts_classify",
+     "Classify files in NEXO_HOME/scripts into personal, core, ignored, and non-script buckets."),
+    (handle_personal_scripts_list, "nexo_personal_scripts_list",
+     "List personal scripts known to NEXO, optionally including attached schedules."),
+    (handle_personal_script_create, "nexo_personal_script_create",
+     "Create a new personal script in NEXO_HOME/scripts, register it, and optionally attach a schedule."),
+    (handle_personal_script_schedules, "nexo_personal_script_schedules",
+     "List registered personal script schedules."),
+    (handle_personal_scripts_reconcile, "nexo_personal_scripts_reconcile",
+     "Classify, sync, and ensure declared personal schedules so NEXO_HOME/scripts and personal crons stay aligned."),
+    (handle_personal_scripts_ensure_schedules, "nexo_personal_scripts_ensure_schedules",
+     "Create or repair personal script schedules declared in inline metadata."),
+    (handle_personal_script_unschedule, "nexo_personal_script_unschedule",
+     "Remove all personal schedules attached to a script without touching core crons."),
+    (handle_personal_script_remove, "nexo_personal_script_remove",
+     "Remove a personal script from the registry and optionally delete its file after unscheduling it."),
+]

package/src/plugins/preferences 2.py

@@ -0,0 +1,47 @@
+"""Preferences plugin — learned behavior patterns and workflow rules."""
+from db import set_preference, get_preference, list_preferences, delete_preference
+
+def handle_preference_get(key: str) -> str:
+    """Get a specific preference by key."""
+    p = get_preference(key)
+    if not p: return f"Preference '{key}' not found."
+    return f"{p['key']} = {p['value']} (cat: {p['category']})"
+
+def handle_preference_set(key: str, value: str, category: str = "general") -> str:
+    """Set a preference (creates or updates)."""
+    set_preference(key, value, category)
+    try:
+        import cognitive
+        cognitive.ingest_to_ltm(f"{key}: {value}", "preference", key, key, "")
+    except Exception:
+        pass
+    return f"Preference '{key}' = '{value}' ({category})"
+
+def handle_preference_list(category: str = "") -> str:
+    """List all preferences, optionally filtered by category."""
+    prefs = list_preferences(category)
+    if not prefs: return "No preferences."
+    grouped = {}
+    for p in prefs:
+        c = p["category"]
+        if c not in grouped: grouped[c] = []
+        grouped[c].append(p)
+    lines = ["PREFERENCES:"]
+    for c, items in grouped.items():
+        lines.append(f"\n  [{c.upper()}]")
+        for p in items:
+            lines.append(f"    {p['key']} = {p['value']}")
+    return "\n".join(lines)
+
+def handle_preference_delete(key: str) -> str:
+    """Delete a preference."""
+    if not delete_preference(key):
+        return f"ERROR: Preference '{key}' not found."
+    return f"Preference '{key}' deleted."
+
+TOOLS = [
+    (handle_preference_get, "nexo_preference_get", "Get a specific preference value"),
+    (handle_preference_set, "nexo_preference_set", "Set a preference (creates or updates)"),
+    (handle_preference_list, "nexo_preference_list", "List all preferences grouped by category"),
+    (handle_preference_delete, "nexo_preference_delete", "Delete a preference"),
+]