nova-data-mcp 0.5.1__py3-none-any.whl

core/analyzers/__init__.py

@@ -0,0 +1 @@
+"""Nova Strategic Analyzers."""

core/analyzers/asset_analyzer.py

@@ -0,0 +1,170 @@
+"""
+asset_analyzer.py - анализ наших ресурсов.
+
+Оценивает: железо (CPU, RAM, disk), код (traces, skills, MCP), данные.
+Возвращает dict со score 0-10 по каждому направлению.
+"""
+
+from __future__ import annotations
+
+import os
+import sqlite3
+from pathlib import Path
+from typing import Any
+
+import psutil
+
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
+DB_PATH = PROJECT_ROOT / "data" / "nova.db"
+
+
+def analyze_hardware() -> dict:
+    """Оценка железа."""
+    cpu_count = psutil.cpu_count(logical=True)
+    cpu_freq = psutil.cpu_freq()
+    ram_gb = psutil.virtual_memory().total / (1024 ** 3)
+    disk = psutil.disk_usage(str(PROJECT_ROOT))
+    disk_free_gb = disk.free / (1024 ** 3)
+
+    # Score: 0-10
+    # CPU: 8+ cores = 5 баллов, 16+ = 8, 24+ = 10
+    cpu_score = min(10, max(1, cpu_count // 3))
+
+    # RAM: 8GB = 3, 16GB = 6, 32GB = 8, 64GB = 10
+    ram_score = min(10, max(1, int(ram_gb / 6)))
+
+    # Disk free: 100GB = 3, 500GB = 7, 1TB = 10
+    disk_score = min(10, max(1, int(disk_free_gb / 100)))
+
+    total = (cpu_score * 0.4 + ram_score * 0.4 + disk_score * 0.2)
+
+    return {
+        "cpu_count": cpu_count,
+        "cpu_freq_mhz": int(cpu_freq.max) if cpu_freq else 0,
+        "ram_gb": round(ram_gb, 1),
+        "disk_free_gb": round(disk_free_gb, 1),
+        "scores": {
+            "cpu": cpu_score,
+            "ram": ram_score,
+            "disk": disk_score,
+        },
+        "total_score": round(total, 1),
+    }
+
+
+def analyze_code() -> dict:
+    """Оценка кода проекта."""
+    if not DB_PATH.exists():
+        return {"error": "nova.db not found", "total_score": 0}
+
+    conn = sqlite3.connect(str(DB_PATH))
+    try:
+        traces = conn.execute("SELECT COUNT(*) FROM traces").fetchone()[0]
+        skills = conn.execute("SELECT COUNT(*) FROM skills").fetchone()[0]
+        orders = conn.execute("SELECT COUNT(*) FROM orders").fetchone()[0]
+    except sqlite3.OperationalError:
+        traces = skills = orders = 0
+    finally:
+        conn.close()
+
+    # MCP-сервер
+    mcp_server = (PROJECT_ROOT / "mcp_server" / "server.py").exists()
+
+    # Оценка
+    # Traces: 50 = 3, 150 = 6, 500 = 9
+    traces_score = min(10, max(1, traces // 20))
+
+    # Skills: 1 = 3, 3 = 6, 10 = 9
+    skills_score = min(10, max(1, skills * 2))
+
+    # MCP: есть = 8, нет = 0
+    mcp_score = 8 if mcp_server else 0
+
+    # Orders: 10 = 3, 50 = 6, 200 = 9
+    orders_score = min(10, max(1, orders // 5))
+
+    total = traces_score * 0.3 + skills_score * 0.3 + mcp_score * 0.2 + orders_score * 0.2
+
+    return {
+        "traces": traces,
+        "skills": skills,
+        "orders": orders,
+        "mcp_server": mcp_server,
+        "scores": {
+            "traces": traces_score,
+            "skills": skills_score,
+            "mcp": mcp_score,
+            "orders": orders_score,
+        },
+        "total_score": round(total, 1),
+    }
+
+
+def analyze_data() -> dict:
+    """Оценка данных (fl.ru)."""
+    if not DB_PATH.exists():
+        return {"error": "nova.db not found", "total_score": 0}
+
+    conn = sqlite3.connect(str(DB_PATH))
+    try:
+        orders = conn.execute("SELECT COUNT(*) FROM orders").fetchone()[0]
+        budgets = conn.execute(
+            "SELECT COUNT(*), AVG(budget) FROM orders WHERE budget > 0"
+        ).fetchone()
+        budgets_count = budgets[0] or 0
+        avg_budget = budgets[1] or 0
+    except sqlite3.OperationalError:
+        orders = budgets_count = 0
+        avg_budget = 0
+    finally:
+        conn.close()
+
+    # Уникальность: fl.ru данные больше никто не продаёт
+    uniqueness_score = 7
+
+    # Объём: 10 заказов = 3, 50 = 6, 200 = 9
+    volume_score = min(10, max(1, orders // 5))
+
+    # Бюджеты: % с бюджетом
+    budget_pct = (budgets_count / orders * 100) if orders else 0
+    budget_score = min(10, max(1, int(budget_pct / 10)))
+
+    total = uniqueness_score * 0.5 + volume_score * 0.3 + budget_score * 0.2
+
+    return {
+        "orders": orders,
+        "with_budget": budgets_count,
+        "avg_budget_rub": round(avg_budget, 0),
+        "scores": {
+            "uniqueness": uniqueness_score,
+            "volume": volume_score,
+            "budget_quality": budget_score,
+        },
+        "total_score": round(total, 1),
+    }
+
+
+def analyze_all() -> dict:
+    """Полный анализ всех ресурсов."""
+    hw = analyze_hardware()
+    code = analyze_code()
+    data = analyze_data()
+
+    total = (
+        hw.get("total_score", 0) * 0.3
+        + code.get("total_score", 0) * 0.4
+        + data.get("total_score", 0) * 0.3
+    )
+
+    return {
+        "hardware": hw,
+        "code": code,
+        "data": data,
+        "overall_score": round(total, 1),
+    }
+
+
+if __name__ == "__main__":
+    import json
+    print(json.dumps(analyze_all(), indent=2, ensure_ascii=False))

core/analyzers/market_parser.py

@@ -0,0 +1,211 @@
+"""
+market_parser.py - парсер рынка.
+
+Собирает данные о рынке из публичных источников:
+- MCP Registry (количество серверов)
+- fl.ru (данные нашего crawler)
+- x402 stats (если публичный)
+- Boosty (рынок цифровых товаров РФ)
+
+Возвращает dict с оценками: размер рынка, конкуренция, тренд.
+"""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+import urllib.request
+import urllib.error
+from pathlib import Path
+from typing import Any
+
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
+DB_PATH = PROJECT_ROOT / "data" / "nova.db"
+
+USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+
+
+def _http_get_json(url: str, timeout: int = 15) -> dict | list | None:
+    """Простой GET с JSON-парсингом."""
+    try:
+        req = urllib.request.Request(url, headers={"User-Agent": USER_AGENT, "Accept": "application/json"})
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            if resp.status == 200:
+                return json.loads(resp.read().decode("utf-8", errors="replace"))
+    except (urllib.error.URLError, urllib.error.HTTPError, OSError, json.JSONDecodeError):
+        return None
+    return None
+
+
+def parse_mcp_registry() -> dict:
+    """MCP Registry — количество серверов."""
+    # Популярные публичные MCP-каталоги
+    sources = [
+        "https://registry.modelcontextprotocol.io/servers",
+        "https://mcp.so/api/servers",
+    ]
+
+    total_servers = 0
+    found_source = None
+
+    for url in sources:
+        data = _http_get_json(url)
+        if data:
+            if isinstance(data, dict):
+                total_servers = data.get("total", data.get("count", 0)) or len(data.get("servers", []))
+            elif isinstance(data, list):
+                total_servers = len(data)
+            if total_servers > 0:
+                found_source = url
+                break
+
+    # Если API не доступны — используем известные данные (12,770+ серверов, <5% монетизированы)
+    if total_servers == 0:
+        total_servers = 12770  # известное число из исследований 2026
+        found_source = "research_data_2026"
+
+    # Оценка: чем больше серверов, тем выше конкуренция
+    # < 1000 = низкая, 5000 = средняя, 20000+ = высокая
+    if total_servers < 1000:
+        competition_score = 3
+    elif total_servers < 5000:
+        competition_score = 5
+    elif total_servers < 15000:
+        competition_score = 7
+    else:
+        competition_score = 9
+
+    # Монетизация: <5% зарабатывают = низкая
+    monetization_rate = 0.05
+
+    return {
+        "total_servers": total_servers,
+        "source": found_source,
+        "monetization_rate": monetization_rate,
+        "competition_score": competition_score,
+        "notes": f"Менее {int(monetization_rate*100)}% MCP-серверов зарабатывают хоть $1 (данные 2026)",
+    }
+
+
+def parse_fl_ru() -> dict:
+    """Данные fl.ru из нашей БД."""
+    if not DB_PATH.exists():
+        return {"error": "nova.db not found", "score": 0}
+
+    conn = sqlite3.connect(str(DB_PATH))
+    try:
+        orders = conn.execute("SELECT COUNT(*) FROM orders").fetchone()[0]
+        budgets = conn.execute(
+            "SELECT AVG(budget), MAX(budget) FROM orders WHERE budget > 0"
+        ).fetchone()
+        avg_budget = budgets[0] or 0
+        max_budget = budgets[1] or 0
+
+        # Последние 24 часа
+        from datetime import datetime, timedelta
+        cutoff = (datetime.now() - timedelta(days=1)).isoformat()
+        recent = conn.execute(
+            "SELECT COUNT(*) FROM orders WHERE found_at > ?", (cutoff,)
+        ).fetchone()[0]
+    except sqlite3.OperationalError:
+        orders = recent = 0
+        avg_budget = max_budget = 0
+    finally:
+        conn.close()
+
+    # Оценка активности рынка
+    # 10 заказов/день = 3, 50 = 6, 200 = 9
+    activity_score = min(10, max(1, recent // 5))
+
+    return {
+        "total_orders_in_db": orders,
+        "orders_last_24h": recent,
+        "avg_budget_rub": round(avg_budget, 0),
+        "max_budget_rub": round(max_budget, 0),
+        "activity_score": activity_score,
+        "notes": f"Медиана IT-заказа на FL.ru: 150,000 ₽ (по данным 2026)",
+    }
+
+
+def parse_x402_stats() -> dict:
+    """x402 stats — объём транзакций."""
+    # Публичный endpoint x402.org для статистики
+    sources = [
+        "https://x402.org/api/stats",
+        "https://api.x402.org/stats",
+    ]
+
+    data = None
+    for url in sources:
+        data = _http_get_json(url)
+        if data:
+            break
+
+    # Если endpoint недоступен — используем известные данные
+    if not data:
+        # Данные из исследований 2026:
+        # - 169M транзакций, $41.6-52.7M объём
+        # - Реальный экономический объём: $5-11K/мес
+        # - Пик: декабрь 2025 (731K транзакций/день)
+        # - Падение: март 2026 (57K транзакций/день, -92%)
+        return {
+            "total_transactions": 169_000_000,
+            "total_volume_usd": 41_600_000,
+            "real_monthly_volume_usd": 8_000,
+            "daily_transactions_peak": 731_000,
+            "daily_transactions_now": 57_000,
+            "decline_pct": 92,
+            "source": "research_data_2026",
+            "trend_score": 3,  # падение
+            "notes": "Реальный экономический объём $5-11K/мес. 92% падение с пика.",
+        }
+
+    return {
+        "data": data,
+        "source": "live_api",
+        "trend_score": 5,
+    }
+
+
+def parse_boosty_market() -> dict:
+    """Рынок цифровых товаров РФ (Boosty/Gumroad)."""
+    # Boosty не даёт публичного API для аналитики.
+    # Используем известные данные из исследований 2026:
+    # - 35% онлайн-покупок — цифровые товары
+    # - Средний чек вырос на 40%
+    # - Количество чеков выросло в 2.2 раза
+    # - Топовые авторы Boosty: 5K подписчиков = 25-30 тыс ₽/мес
+
+    return {
+        "digital_share_of_purchases_pct": 35,
+        "avg_check_growth_pct": 40,
+        "check_count_growth_x": 2.2,
+        "top_boosty_monthly_rub": 30_000,
+        "market_trend": "growing",
+        "trend_score": 8,
+        "notes": "Цифровые товары в РФ растут. Boosty — рабочая площадка.",
+    }
+
+
+def analyze_all() -> dict:
+    """Собирает данные со всех источников."""
+    mcp = parse_mcp_registry()
+    flru = parse_fl_ru()
+    x402 = parse_x402_stats()
+    boosty = parse_boosty_market()
+
+    return {
+        "mcp_registry": mcp,
+        "fl_ru": flru,
+        "x402": x402,
+        "boosty": boosty,
+        "market_summary": {
+            "best_opportunity": "boosty",
+            "reason": "Рынок цифровых товаров РФ растёт (+40% чек, 2.2x чеки). MCP перегрет (12770+ серверов, <5% монетизированы). x402 в падении (-92%).",
+        },
+    }
+
+
+if __name__ == "__main__":
+    print(json.dumps(analyze_all(), indent=2, ensure_ascii=False))

core/analyzers/path_comparator.py

@@ -0,0 +1,207 @@
+"""
+path_comparator.py - сравнивает возможные пути развития.
+
+Берёт данные из asset_analyzer (наши ресурсы) и market_parser (рынок).
+Оценивает пути по 4 критериям:
+- potential (потенциал дохода)
+- complexity (сложность реализации)
+- time_to_income (время до первого дохода)
+- risk (вероятность провала)
+
+Возвращает топ-1 + топ-2 с обоснованием.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Any
+
+# Добавляем корень проекта в sys.path
+_PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
+if str(_PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(_PROJECT_ROOT))
+
+from core.analyzers.asset_analyzer import analyze_all as analyze_assets
+from core.analyzers.market_parser import analyze_all as analyze_market
+
+
+# Веса критериев (сумма = 1.0)
+WEIGHTS = {
+    "potential": 0.40,
+    "complexity": 0.20,   # инвертируется: меньше сложность = больше балл
+    "time_to_income": 0.20,  # инвертируется: меньше время = больше балл
+    "risk": 0.20,         # инвертируется: меньше риск = больше балл
+}
+
+
+# Описание путей
+PATHS = {
+    "boosty": {
+        "name": "Boosty (цифровые товары РФ)",
+        "description": "Ежемесячный отчёт по рынку фриланса РФ. Подписка 990 ₽/мес.",
+        "potential_score": 7,      # 30-100 тыс ₽/мес при 30-100 подписчиках
+        "complexity_score": 4,     # нужен контент, но не код
+        "time_to_income": 5,       # 14 дней до первой подписки
+        "risk_score": 3,           # низкий риск
+        "requirements": ["Контент (PDF/JSON)", "Boosty-страница", "Трафик (Habr/Telegram)"],
+    },
+    "consulting": {
+        "name": "MCP-консалтинг (B2B)",
+        "description": "Разработка кастомных MCP-серверов для бизнеса. $1.5-3K за проект.",
+        "potential_score": 9,      # 100-300 тыс ₽/мес
+        "complexity_score": 8,     # нужны клиенты, переговоры, разработка
+        "time_to_income": 8,       # 30 дней до первого клиента
+        "risk_score": 6,           # средний риск
+        "requirements": ["Портфолио", "Профиль на Upwork/fl.ru", "Навыки продаж"],
+    },
+    "fl_ru_orders": {
+        "name": "fl.ru заказы (активные деньги)",
+        "description": "Ручное выполнение заказов на fl.ru. Nova как ускоритель.",
+        "potential_score": 8,      # 150 тыс ₽ за заказ (медиана IT)
+        "complexity_score": 6,     # нужно выполнять руками
+        "time_to_income": 2,       # 3-7 дней до первого заказа
+        "risk_score": 4,           # низкий риск
+        "requirements": ["Активный профиль на fl.ru", "Навыки выполнения", "Время"],
+    },
+    "public_mcp": {
+        "name": "Публичный MCP + x402",
+        "description": "Публичный MCP-сервер с оплатой через x402. $0.001-0.01 за вызов.",
+        "potential_score": 3,      # $50-500/мес при удаче
+        "complexity_score": 6,     # нужен named tunnel, домен, продвижение
+        "time_to_income": 8,       # 30+ дней до первых вызовов
+        "risk_score": 8,           # высокий риск (x402 в падении)
+        "requirements": ["Публичный endpoint", "MCP Registry", "Трафик агентов"],
+    },
+}
+
+
+def _invert_score(score: int) -> int:
+    """Инвертирует score: 10 → 1, 1 → 10. Для complexity/time/risk."""
+    return 11 - score
+
+
+def compute_path_score(path_key: str) -> dict:
+    """Считает общий score для пути."""
+    path = PATHS[path_key]
+
+    potential = path["potential_score"]
+    complexity = _invert_score(path["complexity_score"])
+    time_to_income = _invert_score(path["time_to_income"])
+    risk = _invert_score(path["risk_score"])
+
+    total = (
+        potential * WEIGHTS["potential"]
+        + complexity * WEIGHTS["complexity"]
+        + time_to_income * WEIGHTS["time_to_income"]
+        + risk * WEIGHTS["risk"]
+    )
+
+    return {
+        "key": path_key,
+        "name": path["name"],
+        "description": path["description"],
+        "scores": {
+            "potential": potential,
+            "complexity_inverted": complexity,
+            "time_inverted": time_to_income,
+            "risk_inverted": risk,
+        },
+        "raw": {
+            "complexity": path["complexity_score"],
+            "time_to_income_days": path["time_to_income"],
+            "risk": path["risk_score"],
+        },
+        "total_score": round(total, 2),
+        "requirements": path["requirements"],
+    }
+
+
+def analyze_all() -> dict:
+    """Сравнивает все пути и даёт рекомендацию."""
+    assets = analyze_assets()
+    market = analyze_market()
+
+    results = []
+    for key in PATHS:
+        result = compute_path_score(key)
+        results.append(result)
+
+    # Сортировка по total_score (убывание)
+    results.sort(key=lambda x: x["total_score"], reverse=True)
+
+    # Корректировка с учётом наших активов и рынка
+    asset_score = assets.get("overall_score", 5)
+    data_unique = assets.get("data", {}).get("scores", {}).get("uniqueness", 5)
+    boosty_trend = market.get("boosty", {}).get("trend_score", 5)
+    x402_trend = market.get("x402", {}).get("trend_score", 5)
+
+    # Бонус к Boosty: если у нас уникальные данные и рынок растёт
+    if data_unique >= 6 and boosty_trend >= 7:
+        for r in results:
+            if r["key"] == "boosty":
+                r["total_score"] = round(r["total_score"] + 0.5, 2)
+
+    # Штраф к public_mcp: если x402 падает
+    if x402_trend <= 4:
+        for r in results:
+            if r["key"] == "public_mcp":
+                r["total_score"] = round(r["total_score"] - 0.5, 2)
+
+    # Пересортировка
+    results.sort(key=lambda x: x["total_score"], reverse=True)
+
+    primary = results[0]
+    secondary = results[1]
+
+    recommendation = {
+        "primary": primary["key"],
+        "primary_name": primary["name"],
+        "primary_score": primary["total_score"],
+        "primary_reason": _build_reason(primary, market, assets),
+        "secondary": secondary["key"],
+        "secondary_name": secondary["name"],
+        "secondary_score": secondary["total_score"],
+        "secondary_reason": _build_reason(secondary, market, assets),
+    }
+
+    return {
+        "our_assets_score": asset_score,
+        "market_summary": market.get("market_summary", {}),
+        "paths": results,
+        "recommendation": recommendation,
+    }
+
+
+def _build_reason(path: dict, market: dict, assets: dict) -> str:
+    """Строит текстовое обоснование для пути."""
+    parts = []
+
+    if path["key"] == "boosty":
+        boosty = market.get("boosty", {})
+        parts.append(f"Рынок цифровых товаров РФ растёт: чек +{boosty.get('avg_check_growth_pct', 0)}%, чеки x{boosty.get('check_count_growth_x', 0)}.")
+        parts.append(f"Доля цифровых товаров в покупках: {boosty.get('digital_share_of_purchases_pct', 0)}%.")
+        parts.append("Наши данные fl.ru уникальны - нет аналогов.")
+
+    elif path["key"] == "consulting":
+        parts.append("MCP-навыки редки, спрос от бизнеса есть.")
+        parts.append("$1.5-3K за кастомный MCP-сервер.")
+        parts.append("Нужны клиенты и портфолио.")
+
+    elif path["key"] == "fl_ru_orders":
+        parts.append("Медиана IT-заказа на FL.ru: 150 тыс руб.")
+        parts.append("Nova ускоряет выполнение.")
+        parts.append("Реальные деньги сейчас, но не пассивно.")
+
+    elif path["key"] == "public_mcp":
+        x402 = market.get("x402", {})
+        parts.append(f"x402 в падении: -{x402.get('decline_pct', 0)}% с пика.")
+        parts.append(f"Реальный объём: ${x402.get('real_monthly_volume_usd', 0)}/мес.")
+        parts.append("Нужен публичный endpoint и трафик агентов.")
+
+    return " ".join(parts)
+
+
+if __name__ == "__main__":
+    import json
+    print(json.dumps(analyze_all(), indent=2, ensure_ascii=False))