nexo-brain 2.2.0 → 2.3.1

package/src/db/_credentials 2.py

@@ -1,124 +0,0 @@
-"""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/_entities 2.py

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