Персональный GitHub-рекап на локальной LLM: код, который не шпионит за твоими коммитами

Год прошёл, а GitHub Wrapped как был поверхностным, так и остался

Каждый декабрь в ленте появляются одинаковые GitHub Wrapped — красивые, но абсолютно бесполезные. 1.2 млн строк кода? Классно. Но что это за строки? Какие проекты реально выросли? Какие технологии ты освоил, а от каких отказался?

Общие цифры не рассказывают историю. Они не показывают, как изменился твой стиль кодирования за год. Не анализируют, стал ли ты писать более чистые коммиты. Не сравнивают январь с декабрем.

Зачем тебе self-hosted LLM для аналитики?

Потому что облачные сервисы аналитики работают по шаблону. Они считают количество, но не понимают качество. Ты можешь накодить тонну легаси-кода и получить медаль «Самый продуктивный разработчик».

Локальная LLM (на 2026 год я рекомендую Llama 3.2 3B или Qwen2.5 3B — обе отлично работают на потребительском железе) понимает контекст. Она может проанализировать:

• Эволюцию архитектурных решений в твоих проектах
• Как изменился стиль именования переменных и функций
• Какие паттерны ты начал использовать чаще, а от каких отказался
• Реальную сложность задач, которые ты решал

И главное — все данные остаются у тебя. Никаких отправок в облако, никаких соглашений о передаче данных.

Архитектура, которая работает на ноутбуке

Не нужно арендовать сервер за $200 в месяц. Вся система строится вокруг трёх компонентов:

1 Сборщик данных

Python-скрипт, который через GitHub API (или локальный git, если хочешь полную приватность) забирает все твои репозитории за выбранный период. На 2026 год GitHub API v4 (GraphQL) стабильнее REST и быстрее.

2 Обработчик и векторная база

Здесь два пути. Первый — классический RAG (полное руководство по RAG поможет разобраться). Второй — более интересный: GitNexus или его аналог, который строит граф знаний из кодовой базы.

Графы работают лучше для анализа эволюции кода. Они видят связи между файлами, понимают, как изменения в одном модуле влияли на другие.

3 Локальная LLM и интерфейс

Llama 3.2 3B quantized (4-битная квантование) весит ~2 ГБ и работает на CPU. Для инференса используй Ollama (самый простой вариант) или llama.cpp для полного контроля.

Интерфейс — Streamlit или Gradio. Оба отлично подходят для быстрого прототипирования аналитических дашбордов.

Что конкретно можно анализировать?

Код, который работает прямо сейчас

Вот минимальный рабочий пример на Python с использованием Ollama и Llama 3.2. На 2026 год это самый стабильный стек для локальных LLM.

import os
from datetime import datetime, timedelta
import requests
import json
from typing import List, Dict
import pandas as pd

class GitHubSelfHostedAnalyzer:
    def __init__(self, github_token: str, ollama_url: str = "http://localhost:11434"):
        self.token = github_token
        self.ollama_url = ollama_url
        self.headers = {
            "Authorization": f"Bearer {self.token}",
            "Accept": "application/vnd.github.v4+json"
        }
    
    def fetch_year_activity(self, username: str, year: int = 2025) -> Dict:
        """Забираем активность за год через GraphQL API"""
        query = """
        query($user: String!, $from: DateTime!, $to: DateTime!) {
          user(login: $user) {
            contributionsCollection(from: $from, to: $to) {
              totalCommitContributions
              totalIssueContributions
              totalPullRequestContributions
              totalRepositoryContributions
              commitContributionsByRepository {
                repository {
                  name
                  languages(first: 10) {
                    nodes { name }
                  }
                }
                contributions(first: 100) {
                  nodes {
                    occurredAt
                    commitCount
                  }
                }
              }
            }
          }
        }
        """
        
        variables = {
            "user": username,
            "from": f"{year}-01-01T00:00:00Z",
            "to": f"{year+1}-01-01T00:00:00Z"
        }
        
        response = requests.post(
            "https://api.github.com/graphql",
            json={"query": query, "variables": variables},
            headers=self.headers
        )
        
        return response.json()
    
    def analyze_with_llm(self, data_summary: str) -> str:
        """Отправляем сводку данных в локальную LLM для анализа"""
        prompt = f"""Ты — аналитик разработки. Проанализируй эту статистику GitHub и дай insights:
        
{data_summary}

Ответь на вопросы:
1. В каких проектах была самая активная разработка?
2. Как менялась активность по месяцам?
3. Какие языки программирования преобладают?
4. Какие выводы можно сделать о стиле разработки?

Будь конкретен и дай рекомендации."""
        
        response = requests.post(
            f"{self.ollama_url}/api/generate",
            json={
                "model": "llama3.2:3b",
                "prompt": prompt,
                "stream": False,
                "options": {"temperature": 0.3}
            }
        )
        
        return response.json().get("response", "Ошибка анализа")
    
    def generate_recap_report(self, username: str, year: int = 2025) -> Dict:
        """Генерируем полный отчёт"""
        # 1. Собираем данные
        activity_data = self.fetch_year_activity(username, year)
        
        # 2. Подготавливаем сводку для LLM
        contributions = activity_data.get("data", {}).get("user", {})\
                        .get("contributionsCollection", {})
        
        summary = f"""Статистика GitHub за {year} год для {username}:
        - Всего коммитов: {contributions.get('totalCommitContributions', 0)}
        - Репозиториев: {contributions.get('totalRepositoryContributions', 0)}
        - Pull Request'ов: {contributions.get('totalPullRequestContributions', 0)}
        - Issues: {contributions.get('totalIssueContributions', 0)}"""
        
        # 3. Анализируем через LLM
        llm_analysis = self.analyze_with_llm(summary)
        
        # 4. Формируем отчёт
        return {
            "year": year,
            "username": username,
            "raw_stats": contributions,
            "llm_analysis": llm_analysis,
            "generated_at": datetime.now().isoformat()
        }

# Использование
analyzer = GitHubSelfHostedAnalyzer(github_token="your_token_here")
report = analyzer.generate_recap_report("your_username", 2025)
print(json.dumps(report, indent=2, ensure_ascii=False))

Это база. На практике нужно добавить кэширование, обработку ошибок и, самое главное — анализ содержимого коммитов, а не только метаданных.

Альтернативы? Есть, но все с компромиссами

Wakatime — показывает время, но не качество. Он не отличает продуктивное кодирование от бесцельного тыкания в клавиатуру.

GitHub's own insights — слишком поверхностные. Они считают количество, игнорируя контекст.

Облачные AI-аналитики (типа OpenClaw для автоматизации) — отправляют твои данные на чужие серверы. В 2026 году это уже не просто паранойя, а разумная предосторожность.

Единственная стоящая альтернатива — GitNexus для глубокого анализа архитектуры. Но он сложнее в настройке и требует больше ресурсов.

Кому это нужно? (Спойлер: почти всем)

• Фрилансерам, которые хотят показать клиентам не просто «я кодил», а конкретные улучшения в их проектах
• Разработчикам, ищущим работу — вместо сухого списка технологий можно показать эволюцию экспертизы (как заставить ИИ рассказать о вас историю)
• Техлидам, которые следят за прогрессом команды (да, систему можно масштабировать на всю команду)
• Перфекционистам, которые хотят видеть, как их код становится чище с каждым годом

Что делать с результатами?

Сгенерированный LLM отчёт — это только начало. На его основе можно:

1. Построить интерактивную визуализацию в Plotly или D3.js
2. Создать PDF-отчёт с графиками и выводами
3. Интегрировать с IDE и CLI-инструментами для постоянного мониторинга
4. Экспортировать данные в Obsidian или Logseq для ведения цифрового сада разработчика

Самый интересный вариант — использовать анализ для планирования следующего года. LLM может предложить, какие технологии изучить, основываясь на твоих прошлых проектах. Не абстрактные «изучи Rust», а конкретные «ты много работал с Python и системами очередей — посмотри на Celery с Redis, это естественное развитие твоих текущих навыков».

Будущее приватной аналитики

К 2027 году такие системы станут стандартом для серьёзных разработчиков. Тренд на приватность только усиливается. Крупные компании уже используют локальные LLM для анализа инцидентов, потому что не могут отправлять логи инцидентов в OpenAI.

Следующий шаг — объединение GitHub-аналитики с данными из других источников: календаря (когда ты наиболее продуктивен), трекера времени, даже данных фитнес-браслета (да, есть корреляция между физической активностью и качеством кода).

Но начинать нужно с малого. Собери статистику за прошлый год. Посмотри, что получится. Удивишься, насколько поверхностными были стандартные GitHub Wrapped.

Код выше — отправная точка. Дополняй его под свои нужды. Добавь анализ сообщений коммитов через ACDD-принципы. Интегрируй визуализацию. Экспериментируй с разными локальными моделями.

Главное — не отправляй свои данные туда, где их могут использовать против тебя. Твоя история разработки стоит больше, чем думаешь.