nexo-brain 7.25.2 → 7.25.4

package/src/local_context/db.py

@@ -18,6 +18,7 @@ MAIN_CLEANUP_STATE_KEY = "local_context_main_tables_drained"
 LOCAL_CONTEXT_TABLES: tuple[str, ...] = (
     "local_index_roots",
     "local_index_exclusions",
+    "local_index_file_type_rules",
     "local_index_jobs",
     "local_index_checkpoints",
     "local_index_state",
@@ -103,10 +104,53 @@ def _ensure_schema(conn: sqlite3.Connection) -> None:
     _m63_local_context_layer(conn)
     _m64_local_context_live_dirs(conn)
     _ensure_entity_dossier_schema(conn)
-    conn.execute("PRAGMA user_version=64")
+    _ensure_local_context_v2_schema(conn)
+    conn.execute("PRAGMA user_version=65")
     conn.commit()
 
 
+def _table_columns(conn: sqlite3.Connection, table: str) -> set[str]:
+    rows = conn.execute(f"PRAGMA table_info({table})").fetchall()
+    return {str(row["name"] if isinstance(row, sqlite3.Row) else row[1]) for row in rows}
+
+
+def _add_column_if_missing(conn: sqlite3.Connection, table: str, column: str, definition: str) -> None:
+    if column in _table_columns(conn, table):
+        return
+    conn.execute(f"ALTER TABLE {table} ADD COLUMN {column} {definition}")
+
+
+def _ensure_local_context_v2_schema(conn: sqlite3.Connection) -> None:
+    """Idempotent local-index v2 schema for managed roots and file type rules."""
+    _add_column_if_missing(conn, "local_index_roots", "source", "TEXT NOT NULL DEFAULT 'legacy'")
+    _add_column_if_missing(conn, "local_index_roots", "remote", "INTEGER NOT NULL DEFAULT 0")
+    _add_column_if_missing(conn, "local_index_roots", "seed_version", "INTEGER NOT NULL DEFAULT 1")
+    _add_column_if_missing(conn, "local_index_exclusions", "source", "TEXT NOT NULL DEFAULT 'legacy'")
+    _add_column_if_missing(conn, "local_index_exclusions", "kind", "TEXT NOT NULL DEFAULT 'folder'")
+    conn.executescript(
+        """
+        CREATE TABLE IF NOT EXISTS local_index_file_type_rules (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            extension TEXT NOT NULL,
+            action TEXT NOT NULL DEFAULT 'ignore',
+            source TEXT NOT NULL DEFAULT 'user',
+            priority INTEGER NOT NULL DEFAULT 0,
+            reason TEXT NOT NULL DEFAULT '',
+            created_at REAL NOT NULL,
+            updated_at REAL NOT NULL,
+            UNIQUE(extension, source)
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_local_index_roots_source
+            ON local_index_roots(source, status);
+        CREATE INDEX IF NOT EXISTS idx_local_index_exclusions_source
+            ON local_index_exclusions(source);
+        CREATE INDEX IF NOT EXISTS idx_local_index_file_type_rules_ext
+            ON local_index_file_type_rules(extension, source);
+        """
+    )
+
+
 def _ensure_entity_dossier_schema(conn: sqlite3.Connection) -> None:
     conn.executescript(
         """

package/src/local_context/extractors.py

@@ -68,6 +68,20 @@ def _read_text(path: Path) -> str:
     return data.decode("utf-8", errors="replace")[:MAX_CHARS]
 
 
+def _read_text_if_safe(path: Path) -> str:
+    data = path.read_bytes()[:MAX_TEXT_BYTES]
+    if not data or b"\x00" in data[:8192]:
+        return ""
+    text = _read_text(path)
+    if not text:
+        return ""
+    printable = sum(1 for char in text[:4096] if char.isprintable() or char.isspace())
+    sample_len = max(1, min(len(text), 4096))
+    if printable / sample_len < 0.85:
+        return ""
+    return text
+
+
 def _extract_csv(path: Path) -> str:
     text = _read_text(path)
     rows = []
@@ -291,7 +305,9 @@ def extract_text(path: Path) -> tuple[str, dict]:
     elif suffix == ".xlsx":
         text = _extract_xlsx(path)
     else:
-        text = ""
+        text = _read_text_if_safe(path)
+        if text:
+            metadata["extractor"] = "generic_text"
     if contains_secret(text):
         metadata["content_secret_detected"] = True
     return clean_text(text), metadata

package/src/plugins/update.py

@@ -12,6 +12,12 @@ import time
 from pathlib import Path
 
 from runtime_home import export_resolved_nexo_home
+try:
+    from product_mode import desktop_product_requested
+except Exception:  # pragma: no cover - stale packaged runtimes may miss product_mode during update
+    def desktop_product_requested() -> bool:
+        return str(os.environ.get("NEXO_DESKTOP_MANAGED", "")).strip() == "1"
+
 from runtime_versioning import (
     activate_versioned_runtime_snapshot,
     compute_mcp_runtime_fingerprint,
@@ -239,15 +245,94 @@ def _venv_pip_path(runtime_root: Path | None = None) -> Path:
     return root / ".venv" / "bin" / "pip"
 
 
+def _python_version_tuple(python_bin: Path | str) -> tuple[int, int, int] | None:
+    try:
+        result = subprocess.run(
+            [str(python_bin), "-c", "import sys; print('.'.join(map(str, sys.version_info[:3])))"],
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+    except Exception:
+        return None
+    if result.returncode != 0:
+        return None
+    match = re.search(r"(\d+)\.(\d+)\.(\d+)", result.stdout or result.stderr or "")
+    if not match:
+        return None
+    return int(match.group(1)), int(match.group(2)), int(match.group(3))
+
+
+def _managed_venv_python_supported(python_bin: Path | str) -> bool:
+    version = _python_version_tuple(python_bin)
+    if not version:
+        return False
+    if desktop_product_requested():
+        return version[:2] == (3, 12)
+    return version >= (3, 10, 0)
+
+
+def _resolve_managed_venv_base_python() -> str:
+    candidates = [
+        os.environ.get("NEXO_BOOTSTRAP_PYTHON", ""),
+        os.environ.get("NEXO_RUNTIME_PYTHON", ""),
+        os.environ.get("NEXO_PYTHON", ""),
+    ]
+    if desktop_product_requested():
+        candidates.extend([
+            "/Library/Frameworks/Python.framework/Versions/3.12/bin/python3.12",
+            "/Library/Frameworks/Python.framework/Versions/3.12/bin/python3",
+            "/opt/homebrew/bin/python3.12",
+            "/usr/local/bin/python3.12",
+            shutil.which("python3.12") or "",
+        ])
+    candidates.extend([sys.executable, shutil.which("python3") or ""])
+    for candidate in candidates:
+        clean = str(candidate or "").strip()
+        if clean and Path(clean).exists() and _managed_venv_python_supported(clean):
+            return clean
+    return sys.executable
+
+
+def _archive_incompatible_managed_venv(root: Path, reason: str = "incompatible-python") -> Path | None:
+    venv_dir = root / ".venv"
+    if not venv_dir.exists():
+        return None
+    backup_root = root / "runtime" / "backups"
+    stamp = time.strftime("%Y%m%d-%H%M%S")
+    try:
+        backup_root.mkdir(parents=True, exist_ok=True)
+        target = backup_root / f"venv-{reason}-{stamp}"
+        counter = 2
+        while target.exists():
+            target = backup_root / f"venv-{reason}-{stamp}-{counter}"
+            counter += 1
+        shutil.move(str(venv_dir), str(target))
+        return target
+    except Exception:
+        return None
+
+
 def _ensure_managed_venv(runtime_root: Path | None = None) -> str | None:
     root = runtime_root or _nexo_home()
     venv_python = _venv_python_path(root)
+    if venv_python.exists():
+        if _managed_venv_python_supported(venv_python):
+            return None
+        version = _python_version_tuple(venv_python)
+        reason = f"python-{'.'.join(map(str, version[:2]))}" if version else "unreadable-python"
+        archived = _archive_incompatible_managed_venv(root, reason=reason)
+        if archived is None:
+            return "managed venv uses an incompatible Python and could not be archived"
+    base_python = _resolve_managed_venv_base_python()
+    if not _managed_venv_python_supported(base_python):
+        return f"no supported Python found for managed venv: {base_python}"
     if venv_python.exists():
         return None
     try:
         root.mkdir(parents=True, exist_ok=True)
         result = subprocess.run(
-            [sys.executable, "-m", "venv", str(root / ".venv")],
+            [base_python, "-m", "venv", str(root / ".venv")],
             capture_output=True,
             text=True,
             timeout=120,
@@ -676,6 +761,8 @@ def _reinstall_pip_deps() -> str | None:
         if alt_pip.exists():
             venv_pip = alt_pip
     if not venv_pip.exists():
+        if desktop_product_requested():
+            return "managed Desktop venv pip is unavailable after repair"
         # No venv, try system pip with --break-system-packages
         try:
             result = subprocess.run(

package/src/server.py

@@ -1026,6 +1026,32 @@ def nexo_local_index_exclusions(action: str = "list", path: str = "", reason: st
     return json.dumps(result, ensure_ascii=False)
 
 
+@mcp.tool
+def nexo_local_index_filetypes(action: str = "list", extension: str = "", mode: str = "extract", reason: str = "user") -> str:
+    """List, include, exclude or reset local memory file extension rules."""
+    normalized = str(action or "list").strip().lower()
+    if normalized == "list":
+        result = local_context_api.list_file_type_rules(readonly=True)
+    elif normalized in {"include", "add"}:
+        result = local_context_api.set_file_type_rule(extension, action=mode or "extract", reason=reason)
+    elif normalized in {"exclude", "ignore"}:
+        result = local_context_api.set_file_type_rule(extension, action="ignore", reason=reason)
+    elif normalized in {"remove", "delete"}:
+        result = local_context_api.remove_file_type_rule(extension)
+    elif normalized == "reset":
+        result = local_context_api.reset_file_type_rules()
+    else:
+        result = {"ok": False, "error": "unknown_action", "allowed": ["list", "include", "exclude", "remove", "reset"]}
+    return json.dumps(result, ensure_ascii=False)
+
+
+@mcp.tool
+def nexo_local_index_migrate_roots_v2(apply: bool = False) -> str:
+    """Plan or apply Local Memory roots v2 cleanup."""
+    result = local_context_api.migrate_roots_seed_v2(dry_run=not bool(apply))
+    return json.dumps(result, ensure_ascii=False)
+
+
 @mcp.tool
 def nexo_local_context(
     query: str,

package/tool-enforcement-map.json

@@ -2502,6 +2502,37 @@
       },
       "triggers_after": []
     },
+    "nexo_local_index_filetypes": {
+      "description": "List, include, exclude, remove, or reset Local Context file extension rules",
+      "category": "local_context",
+      "source": "server",
+      "requires": [],
+      "provides": [
+        "local_index_file_type_rules"
+      ],
+      "internal_calls": [],
+      "enforcement": {
+        "level": "none",
+        "rules": []
+      },
+      "triggers_after": []
+    },
+    "nexo_local_index_migrate_roots_v2": {
+      "description": "Plan or apply Local Context roots v2 cleanup",
+      "category": "local_context",
+      "source": "server",
+      "requires": [],
+      "provides": [
+        "local_index_roots",
+        "local_index_cleanup"
+      ],
+      "internal_calls": [],
+      "enforcement": {
+        "level": "none",
+        "rules": []
+      },
+      "triggers_after": []
+    },
     "nexo_local_index_models": {
       "description": "Inspect or warm Local Context local model availability",
       "category": "local_context",