nexo-brain 2.1.0 → 2.3.0

package/src/db/_credentials 2.py

@@ -0,0 +1,124 @@
+"""NEXO DB — Credentials module."""
+import sqlite3, time
+from db._core import get_db, now_epoch
+
+# ── Credentials ────────────────────────────────────────────────────
+
+def create_credential(service: str, key: str, value: str, notes: str = '') -> dict:
+    """Create a new credential entry."""
+    conn = get_db()
+    now = now_epoch()
+    try:
+        conn.execute(
+            "INSERT INTO credentials (service, key, value, notes, created_at, updated_at) "
+            "VALUES (?, ?, ?, ?, ?, ?)",
+            (service, key, value, notes, now, now)
+        )
+        conn.commit()
+    except sqlite3.IntegrityError:
+        return {"error": f"Credential {service}/{key} already exists. Use update instead."}
+    row = conn.execute(
+        "SELECT * FROM credentials WHERE service = ? AND key = ?", (service, key)
+    ).fetchone()
+    return dict(row)
+
+
+def update_credential(service: str, key: str, value: str = None, notes: str = None) -> dict:
+    """Update value and/or notes for a credential."""
+    conn = get_db()
+    row = conn.execute(
+        "SELECT * FROM credentials WHERE service = ? AND key = ?", (service, key)
+    ).fetchone()
+    if not row:
+            return {"error": f"Credential {service}/{key} not found"}
+    updates = {"updated_at": now_epoch()}
+    if value is not None:
+        updates["value"] = value
+    if notes is not None:
+        updates["notes"] = notes
+    set_clause = ", ".join(f"{k} = ?" for k in updates)
+    values = list(updates.values()) + [service, key]
+    conn.execute(
+        f"UPDATE credentials SET {set_clause} WHERE service = ? AND key = ?", values
+    )
+    conn.commit()
+    row = conn.execute(
+        "SELECT * FROM credentials WHERE service = ? AND key = ?", (service, key)
+    ).fetchone()
+    return dict(row)
+
+
+def delete_credential(service: str, key: str = None) -> bool:
+    """Delete credential(s). If key=None, delete all for the service."""
+    conn = get_db()
+    if key:
+        result = conn.execute(
+            "DELETE FROM credentials WHERE service = ? AND key = ?", (service, key)
+        )
+    else:
+        result = conn.execute(
+            "DELETE FROM credentials WHERE service = ?", (service,)
+        )
+    conn.commit()
+    deleted = result.rowcount > 0
+    return deleted
+
+
+def get_credential(service: str, key: str = None) -> list[dict]:
+    """Get credential(s). If key=None, return all for the service.
+
+    When exact match fails, performs fuzzy search across service, key,
+    value and notes fields. Returns results tagged with _fuzzy=True so
+    the caller can differentiate suggestions from exact hits.
+    """
+    conn = get_db()
+    if key:
+        rows = conn.execute(
+            "SELECT * FROM credentials WHERE service = ? AND key = ?", (service, key)
+        ).fetchall()
+    else:
+        rows = conn.execute(
+            "SELECT * FROM credentials WHERE service = ?", (service,)
+        ).fetchall()
+    if rows:
+        return [dict(r) for r in rows]
+
+    # Fuzzy fallback: search term in service, key and notes (not value — too noisy)
+    # Prioritize: service/key matches first, notes-only matches second
+    term = f"%{service}%"
+    fuzzy_rows = conn.execute(
+        "SELECT *, "
+        "CASE WHEN service LIKE ? THEN 0 "
+        "     WHEN key LIKE ? THEN 1 "
+        "     ELSE 2 END AS _rank "
+        "FROM credentials WHERE "
+        "service LIKE ? OR key LIKE ? OR notes LIKE ? "
+        "ORDER BY _rank ASC, service ASC, key ASC",
+        (term, term, term, term, term),
+    ).fetchall()
+    results = []
+    for r in fuzzy_rows:
+        d = dict(r)
+        d["_fuzzy"] = True
+        d.pop("_rank", None)
+        results.append(d)
+    return results
+
+
+def list_credentials(service: str = None) -> list[dict]:
+    """List service+key only (NO values) for security."""
+    conn = get_db()
+    if service:
+        rows = conn.execute(
+            "SELECT id, service, key, notes, created_at, updated_at "
+            "FROM credentials WHERE service = ? ORDER BY key ASC",
+            (service,)
+        ).fetchall()
+    else:
+        rows = conn.execute(
+            "SELECT id, service, key, notes, created_at, updated_at "
+            "FROM credentials ORDER BY service ASC, key ASC"
+        ).fetchall()
+    return [dict(r) for r in rows]
+
+

package/src/db/_cron_runs.py

@@ -0,0 +1,74 @@
+"""NEXO DB — Cron execution history."""
+from db._core import get_db
+
+
+def cron_run_start(cron_id: str) -> int:
+    """Record a cron starting. Returns the run ID."""
+    conn = get_db()
+    cursor = conn.execute(
+        "INSERT INTO cron_runs (cron_id) VALUES (?)", (cron_id,)
+    )
+    conn.commit()
+    return cursor.lastrowid
+
+
+def cron_run_end(run_id: int, exit_code: int, summary: str = '', error: str = ''):
+    """Record a cron finishing."""
+    conn = get_db()
+    conn.execute(
+        """UPDATE cron_runs
+           SET ended_at = datetime('now'),
+               exit_code = ?,
+               summary = ?,
+               error = ?,
+               duration_secs = ROUND((julianday(datetime('now')) - julianday(started_at)) * 86400, 1)
+           WHERE id = ?""",
+        (exit_code, summary[:500], error[:500], run_id)
+    )
+    conn.commit()
+
+
+def cron_runs_recent(hours: int = 24, cron_id: str = '') -> list[dict]:
+    """Get recent cron executions."""
+    conn = get_db()
+    if cron_id:
+        rows = conn.execute(
+            """SELECT * FROM cron_runs
+               WHERE cron_id = ? AND started_at >= datetime('now', ?)
+               ORDER BY started_at DESC""",
+            (cron_id, f"-{hours} hours")
+        ).fetchall()
+    else:
+        rows = conn.execute(
+            """SELECT * FROM cron_runs
+               WHERE started_at >= datetime('now', ?)
+               ORDER BY started_at DESC""",
+            (f"-{hours} hours",)
+        ).fetchall()
+    return [dict(r) for r in rows]
+
+
+def cron_runs_summary(hours: int = 24) -> list[dict]:
+    """Get summary per cron: last run, success rate, avg duration."""
+    conn = get_db()
+    rows = conn.execute(
+        """SELECT
+               cron_id,
+               COUNT(*) as total_runs,
+               SUM(CASE WHEN exit_code = 0 THEN 1 ELSE 0 END) as succeeded,
+               SUM(CASE WHEN exit_code != 0 OR exit_code IS NULL THEN 1 ELSE 0 END) as failed,
+               ROUND(AVG(duration_secs), 1) as avg_duration,
+               MAX(started_at) as last_run,
+               (SELECT exit_code FROM cron_runs cr2
+                WHERE cr2.cron_id = cron_runs.cron_id
+                ORDER BY started_at DESC LIMIT 1) as last_exit_code,
+               (SELECT summary FROM cron_runs cr3
+                WHERE cr3.cron_id = cron_runs.cron_id AND cr3.summary != ''
+                ORDER BY started_at DESC LIMIT 1) as last_summary
+           FROM cron_runs
+           WHERE started_at >= datetime('now', ?)
+           GROUP BY cron_id
+           ORDER BY last_run DESC""",
+        (f"-{hours} hours",)
+    ).fetchall()
+    return [dict(r) for r in rows]

package/src/db/_entities 2.py

@@ -0,0 +1,178 @@
+"""NEXO DB — Entities module."""
+import time
+from db._core import get_db, _multi_word_like
+from db._fts import fts_upsert
+
+# ── Entities ──────────────────────────────────────────────────────
+
+def create_entity(name: str, type: str, value: str, notes: str = "") -> int:
+    """Create a new entity. Returns the entity ID."""
+    conn = get_db()
+    now = time.time()
+    cursor = conn.execute(
+        "INSERT INTO entities (name, type, value, notes, created_at, updated_at) "
+        "VALUES (?, ?, ?, ?, ?, ?)",
+        (name, type, value, notes, now, now)
+    )
+    conn.commit()
+    eid = cursor.lastrowid
+    fts_upsert("entity", str(eid), name, f"{name} {value} {notes}", type or "general", commit=False)
+    return eid
+
+
+def search_entities(query: str, type: str = "") -> list[dict]:
+    """Search entities by name or value. Multi-word AND search."""
+    conn = get_db()
+    frag, params = _multi_word_like(query, ["name", "value"])
+    if type:
+        where = f"type = ? AND ({frag})"
+        params.insert(0, type)
+    else:
+        where = frag
+    rows = conn.execute(
+        f"SELECT * FROM entities WHERE {where} ORDER BY updated_at DESC",
+        params
+    ).fetchall()
+    return [dict(r) for r in rows]
+
+
+def list_entities(type: str = "") -> list[dict]:
+    """List all entities, optionally filtered by type."""
+    conn = get_db()
+    if type:
+        rows = conn.execute(
+            "SELECT * FROM entities WHERE type = ? ORDER BY name ASC",
+            (type,)
+        ).fetchall()
+    else:
+        rows = conn.execute(
+            "SELECT * FROM entities ORDER BY type ASC, name ASC"
+        ).fetchall()
+    return [dict(r) for r in rows]
+
+
+def update_entity(id: int, **kwargs):
+    """Update entity fields: name, type, value, notes."""
+    conn = get_db()
+    allowed = {"name", "type", "value", "notes"}
+    updates = {k: v for k, v in kwargs.items() if k in allowed}
+    if not updates:
+            return
+    updates["updated_at"] = time.time()
+    set_clause = ", ".join(f"{k} = ?" for k in updates)
+    values = list(updates.values()) + [id]
+    conn.execute(f"UPDATE entities SET {set_clause} WHERE id = ?", values)
+    conn.commit()
+    row = conn.execute("SELECT * FROM entities WHERE id = ?", (id,)).fetchone()
+    if row:
+        r = dict(row)
+        fts_upsert("entity", str(id), r.get("name",""), f"{r.get('name','')} {r.get('value','')} {r.get('notes','')}", r.get("type","general"), commit=False)
+
+
+def delete_entity(id: int) -> bool:
+    """Delete an entity. Returns True if deleted, False if not found."""
+    conn = get_db()
+    result = conn.execute("DELETE FROM entities WHERE id = ?", (id,))
+    conn.execute("DELETE FROM unified_search WHERE source = 'entity' AND source_id = ?", (str(id),))
+    conn.commit()
+    return result.rowcount > 0
+
+
+# ── Preferences ───────────────────────────────────────────────────
+
+def set_preference(key: str, value: str, category: str = "general"):
+    """Set a preference (insert or update)."""
+    conn = get_db()
+    now = time.time()
+    conn.execute(
+        "INSERT OR REPLACE INTO preferences (key, value, category, updated_at) "
+        "VALUES (?, ?, ?, ?)",
+        (key, value, category, now)
+    )
+    conn.commit()
+
+
+def get_preference(key: str) -> dict | None:
+    """Get a single preference by key."""
+    conn = get_db()
+    row = conn.execute("SELECT * FROM preferences WHERE key = ?", (key,)).fetchone()
+    return dict(row) if row else None
+
+
+def list_preferences(category: str = "") -> list[dict]:
+    """List all preferences, optionally filtered by category."""
+    conn = get_db()
+    if category:
+        rows = conn.execute(
+            "SELECT * FROM preferences WHERE category = ? ORDER BY key ASC",
+            (category,)
+        ).fetchall()
+    else:
+        rows = conn.execute(
+            "SELECT * FROM preferences ORDER BY category ASC, key ASC"
+        ).fetchall()
+    return [dict(r) for r in rows]
+
+
+def delete_preference(key: str) -> bool:
+    """Delete a preference. Returns True if deleted, False if not found."""
+    conn = get_db()
+    result = conn.execute("DELETE FROM preferences WHERE key = ?", (key,))
+    conn.commit()
+    return result.rowcount > 0
+
+
+# ── Agents ────────────────────────────────────────────────────────
+
+def create_agent(id: str, name: str, specialization: str, model: str = "sonnet",
+                 tools: str = "", context_files: str = "", rules: str = "") -> dict:
+    """Register a new agent. Uses INSERT OR REPLACE to allow re-registration."""
+    conn = get_db()
+    now = time.time()
+    conn.execute(
+        "INSERT OR REPLACE INTO agents (id, name, specialization, model, tools, context_files, rules, created_at, updated_at) "
+        "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+        (id, name, specialization, model, tools, context_files, rules, now, now)
+    )
+    conn.commit()
+    return {"id": id, "name": name}
+
+
+def get_agent(id: str) -> dict | None:
+    """Get an agent by ID."""
+    conn = get_db()
+    row = conn.execute("SELECT * FROM agents WHERE id = ?", (id,)).fetchone()
+    return dict(row) if row else None
+
+
+def list_agents() -> list[dict]:
+    """List all registered agents."""
+    conn = get_db()
+    rows = conn.execute(
+        "SELECT * FROM agents ORDER BY name ASC"
+    ).fetchall()
+    return [dict(r) for r in rows]
+
+
+def update_agent(id: str, **kwargs):
+    """Update agent fields: name, specialization, model, tools, context_files, rules."""
+    conn = get_db()
+    allowed = {"name", "specialization", "model", "tools", "context_files", "rules"}
+    updates = {k: v for k, v in kwargs.items() if k in allowed}
+    if not updates:
+            return
+    updates["updated_at"] = time.time()
+    set_clause = ", ".join(f"{k} = ?" for k in updates)
+    values = list(updates.values()) + [id]
+    conn.execute(f"UPDATE agents SET {set_clause} WHERE id = ?", values)
+    conn.commit()
+
+
+def delete_agent(id: str) -> bool:
+    """Delete an agent. Returns True if deleted, False if not found."""
+    conn = get_db()
+    result = conn.execute("DELETE FROM agents WHERE id = ?", (id,))
+    conn.commit()
+    return result.rowcount > 0
+
+