Платформа ЦИФРА — Многосрезовый анализ

ПЛАТФОРМА ЦИФРА
│
├─ УРОВЕНЬ 1: ИНФРАСТРУКТУРА (✅ ЕСТЬ)
│  ├─ Workspace Structure
│  │  ├─ platform/ (ядро системы)
│  │  ├─ templates/ (библиотека шаблонов)
│  │  ├─ components/ (FSD компоненты)
│  │  ├─ tests/ (библиотека тестов)
│  │  ├─ projects/ (пользовательские проекты)
│  │  └─ archive/ (архив)
│  │
│  ├─ Cascade Search System
│  │  ├─ L1: Platform rules (platform/CLAUDE.md)
│  │  ├─ L2: Registry (external libs)
│  │  ├─ L3: Templates (templates/*)
│  │  ├─ L4: Components (components/*)
│  │  ├─ L5: Projects code (projects/*)
│  │  ├─ L6: Archive (archive/*)
│  │  └─ L7: Generate (Claude API)
│  │
│  ├─ Token Economy System
│  │  ├─ Metrics collector
│  │  ├─ ROI calculator
│  │  └─ Reports generator
│  │
│  ├─ Documentation System
│  │  ├─ Platform docs (platform/*.md)
│  │  ├─ Template docs (templates/*/README.md)
│  │  ├─ Project docs (projects/*/design/*.md)
│  │  └─ API docs (Streamlit guides)
│  │
│  └─ Version Control
│     ├─ Git (монорепозиторий)
│     ├─ Semantic Versioning (templates)
│     └─ Journaling (system-journal.md)
│
└─ УРОВЕНЬ 2: АГЕНТЫ (🔮 ПЛАНИРУЕТСЯ)
   ├─ Core Agents (Фаза 0-1)
   │  ├─ BaseAgent (базовый класс)
   │  ├─ DocumentAgent (документация)
   │  ├─ CodeAgent (генерация кода)
   │  ├─ GitAgent (версии)
   │  ├─ ProjectAgent (управление проектами)
   │  └─ TestAgent (тестирование)
   │
   ├─ Lifecycle Agents (Фаза 3)
   │  ├─ DeployAgent (деплой)
   │  ├─ MonitorAgent (мониторинг)
   │  └─ BugfixAgent (исправление багов)
   │
   ├─ Meta Agents (Фаза 4)
   │  ├─ MetaAgent (саморазвитие)
   │  └─ AnalyticsAgent (анализ)
   │
   ├─ Interface Agents (Фаза 5)
   │  ├─ VoiceAgent (голос)
   │  └─ CLIAgent (команды)
   │
   └─ Coordination Layer (Фаза 2)
      ├─ CentralAgent (координатор)
      ├─ AgentAPI (hub)
      └─ WorkflowEngine (процессы)

Пользователь
    ↓
[VoiceAgent / CLIAgent] ← ИНТЕРФЕЙСНЫЙ СЛОЙ
    ↓
[CentralAgent] ← КООРДИНАЦИЯ
    ↓
[AgentAPI] ← HUB
    ↓ ↓ ↓ ↓ ↓ ↓
[DocumentAgent] [CodeAgent] [GitAgent] [ProjectAgent] [TestAgent] ... ← АГЕНТЫ
    ↓ ↓ ↓ ↓ ↓
[Cascade Search] ← ПОИСК РЕШЕНИЙ
    ↓
[Templates + Components + Tests] ← ИНФРАСТРУКТУРА
    ↓
[Git + Journal] ← ВЕРСИОНИРОВАНИЕ
    ↓
Результат → Пользователь

# 1. Создать класс
class NewAgent(BaseAgent):
    def execute(self, task):
        pass

# 2. Зарегистрировать
api.register_agent(NewAgent())

# 3. Использовать
api.call_agent("NewAgent", task)

Вход: Название проекта + шаблон + параметры
Процесс:
  1. ProjectAgent читает template.yaml
  2. Запрашивает переменные
  3. Создаёт структуру projects/{name}/
  4. DocumentAgent генерирует PROJECT.md
  5. CodeAgent копирует код из шаблона
  6. TestAgent создаёт тесты
  7. GitAgent делает commit
Выход: Готовый проект

Вход: Описание задачи
Процесс:
  1. CodeAgent → Cascade Search (L1-L7)
  2. Если найдено (L3-L6) → копировать и адаптировать
  3. Если НЕ найдено → генерировать через Claude API (L7)
  4. Сохранить результат
Выход: Код функции/модуля
Экономия: 80-86% tokens (если найдено)

Вход: Тип документа + данные проекта
Процесс:
  1. DocumentAgent ищет пример (существующий PROJECT.md)
  2. Вызывает Claude API с промптом + пример
  3. Claude генерирует новый документ в том же стиле
  4. Сохранение в projects/{name}/design/
Выход: PROJECT.md / ROADMAP.md / ARCHITECTURE.md

Вход: Путь к модулю
Процесс:
  1. TestAgent анализирует код
  2. Генерирует pytest тесты
  3. Запускает тесты
  4. Собирает coverage
  5. Отчёт о результатах
Выход: Тесты + отчёт

Вход: Проект + environment (staging/production)
Процесс:
  1. DeployAgent читает infrastructure/deploy.yaml
  2. SSH на сервер
  3. Деплой через Docker / systemd
  4. Health check
  5. Обновление CHANGELOG.md
Выход: Развёрнутое приложение

Процесс (постоянный):
  1. MonitorAgent проверяет серверы (каждые N минут)
  2. Health checks приложений
  3. Сбор метрик (CPU, RAM, errors)
  4. При проблеме → алерт → BugfixAgent
Выход: Метрики + алерты

Вход: Сообщение об ошибке
Процесс:
  1. BugfixAgent анализирует логи
  2. Воспроизводит ошибку (TestAgent)
  3. Ищет решение в Git истории
  4. Генерирует патч (CodeAgent)
  5. Тестирует патч (TestAgent)
  6. Применяет (GitAgent)
Выход: Исправленный код

Процесс (периодический):
  1. MetaAgent анализирует метрики платформы
  2. Находит паттерны (часто используемый код → в components/)
  3. Анализирует производительность агентов
  4. Генерирует улучшения
  5. Тестирует улучшения
  6. Применяет (через другие агенты)
Выход: Улучшенная платформа

Вход: Голосовая команда
Процесс:
  1. VoiceAgent записывает аудио
  2. Whisper API → текст
  3. NLU (через Claude) → понимание команды
  4. CentralAgent → выполнение через агентов
  5. Результат → текст
  6. ElevenLabs API → голос
  7. VoiceAgent озвучивает результат
Выход: Голосовой ответ

User Input (голос/текст)
    ↓
VoiceAgent: аудио → текст
    ↓
CentralAgent: parse команды
    ↓
Workflow: create_project
    ↓
    ├→ ProjectAgent: создать структуру
    │     ↓ (читает templates/)
    │     ↓ (пишет projects/{name}/)
    │
    ├→ DocumentAgent: создать PROJECT.md
    │     ↓ (читает примеры из projects/)
    │     ↓ (вызывает Claude API)
    │     ↓ (пишет design/PROJECT.md)
    │
    ├→ CodeAgent: скопировать код
    │     ↓ (Cascade Search в templates/)
    │     ↓ (адаптирует через Claude API)
    │     ↓ (пишет solution/*)
    │
    ├→ TestAgent: создать тесты
    │     ↓ (анализирует solution/*)
    │     ↓ (генерирует tests/)
    │
    └→ GitAgent: commit
          ↓ (git add + commit)
          ↓ (обновляет system-journal.md)
    ↓
CentralAgent: собирает результаты
    ↓
VoiceAgent: текст → голос
    ↓
User Output (голосовой ответ)

┌─────────────────────────────────────────────────────────┐
│ ЭТАП 1: КОНЦЕПЦИЯ (✅ ЗАВЕРШЁН)                        │
│ - Определение требований                                │
│ - Архитектурное видение                                 │
│ - Технологический стек                                  │
│ Результат: PLATFORM_OVERVIEW.md, DEVELOPMENT_SEQUENCE.md│
└─────────────────────────────────────────────────────────┘
                    ↓
┌─────────────────────────────────────────────────────────┐
│ ЭТАП 2: ИНФРАСТРУКТУРА (✅ ЗАВЕРШЁН)                   │
│ - Создание workspace структуры                          │
│ - Cascade Search реализация                             │
│ - Templates + Components                                │
│ - Token Economy                                         │
│ - Документация                                          │
│ Результат: 48 файлов, 9,000 строк, 11 коммитов         │
└─────────────────────────────────────────────────────────┘
                    ↓
┌─────────────────────────────────────────────────────────┐
│ ЭТАП 3: BOOTSTRAP (🔮 ПЛАНИРУЕТСЯ - Фаза 0)           │
│ - Создание 3 базовых агентов вручную                   │
│ - DocumentAgent, CodeAgent, GitAgent                    │
│ - AgentAPI                                              │
│ - Тестирование bootstrap                                │
│ Результат: ~650 строк кода, 3 агента работают          │
└─────────────────────────────────────────────────────────┘
                    ↓
┌─────────────────────────────────────────────────────────┐
│ ЭТАП 4: SELF-CREATION (🔮 ПЛАНИРУЕТСЯ - Фаза 1)       │
│ - 3 агента создают ProjectAgent                         │
│ - 3 агента создают TestAgent                            │
│ - Проверка концепции самосоздания                       │
│ Результат: 5 агентов, доказательство концепции         │
└─────────────────────────────────────────────────────────┘
                    ↓
┌─────────────────────────────────────────────────────────┐
│ ЭТАП 5: COORDINATION (🔮 ПЛАНИРУЕТСЯ - Фаза 2)        │
│ - Создание CentralAgent                                 │
│ - WorkflowEngine                                        │
│ - CLI интерфейс                                         │
│ Результат: Координация агентов работает                │
└─────────────────────────────────────────────────────────┘
                    ↓
┌─────────────────────────────────────────────────────────┐
│ ЭТАП 6: FULL LIFECYCLE (🔮 ПЛАНИРУЕТСЯ - Фаза 3)      │
│ - DeployAgent, MonitorAgent, BugfixAgent                │
│ - Интеграция с Docker/SSH                               │
│ - Полный цикл: разработка → production                  │
│ Результат: Платформа покрывает весь цикл               │
└─────────────────────────────────────────────────────────┘
                    ↓
┌─────────────────────────────────────────────────────────┐
│ ЭТАП 7: META (🔮 ПЛАНИРУЕТСЯ - Фаза 4)                │
│ - MetaAgent — саморазвитие                              │
│ - Analytics — сбор метрик                               │
│ - SelfImprovement — автоматические улучшения            │
│ Результат: Платформа улучшает себя                     │
└─────────────────────────────────────────────────────────┘
                    ↓
┌─────────────────────────────────────────────────────────┐
│ ЭТАП 8: VOICE (🔮 ПЛАНИРУЕТСЯ - Фаза 5)               │
│ - VoiceAgent                                            │
│ - Whisper + ElevenLabs интеграция                       │
│ - NLU для команд                                        │
│ Результат: Голосовое управление платформой             │
└─────────────────────────────────────────────────────────┘
                    ↓
┌─────────────────────────────────────────────────────────┐
│ ЭТАП 9: PRODUCTION (🔮 БУДУЩЕЕ)                        │
│ - Масштабирование                                       │
│ - Безопасность                                          │
│ - Документация для пользователей                        │
│ - Коммерциализация (опционально)                        │
└─────────────────────────────────────────────────────────┘

1. СПЕЦИФИКАЦИЯ (вручную)
   - Описание функций агента
   - Методы и параметры
   - Примеры использования

2. ГЕНЕРАЦИЯ КОДА (через CodeAgent)
   - CodeAgent.execute({
       type: "create_module",
       description: "Создай AgentX класс...",
       template: "BaseAgent",
       output: "platform/agents/agent_x.py"
     })

3. ДОКУМЕНТАЦИЯ (через DocumentAgent)
   - DocumentAgent.execute({
       type: "create_agent_docs",
       agent_name: "AgentX",
       output: "platform/docs/AgentX.md"
     })

4. ТЕСТЫ (через TestAgent)
   - TestAgent.execute({
       type: "create_test",
       module: "platform.agents.agent_x",
       output: "tests/test_agent_x.py"
     })

5. ТЕСТИРОВАНИЕ
   - pytest tests/test_agent_x.py
   - Проверка интеграции с AgentAPI

6. GIT COMMIT (через GitAgent)
   - GitAgent.execute({
       type: "commit",
       message: "feat: добавлен AgentX",
       files: ["platform/agents/agent_x.py", ...]
     })

7. РЕГИСТРАЦИЯ
   - api.register_agent(AgentX())

8. ОБНОВЛЕНИЕ JOURNAL
   - Запись в system-journal.md

ЦИКЛ (каждые N дней):

1. СБОР ДАННЫХ
   - Анализ логов всех агентов
   - Метрики производительности
   - Token usage статистика
   - Git история

2. АНАЛИЗ ПАТТЕРНОВ
   - Часто дублируемый код → кандидат в components/
   - Медленные операции → оптимизация
   - Частые ошибки → улучшение обработки

3. ГЕНЕРАЦИЯ УЛУЧШЕНИЙ
   - MetaAgent вызывает Claude API:
     "Проанализируй эти паттерны и предложи улучшения"

4. ПРИОРИТИЗАЦИЯ
   - ROI расчёт (польза / усилия)
   - Сортировка по приоритету

5. ТЕСТИРОВАНИЕ УЛУЧШЕНИЙ
   - Создать ветку
   - Применить улучшение
   - Запустить все тесты
   - Измерить метрики (до/после)

6. ПРИНЯТИЕ РЕШЕНИЯ
   - Если тесты ✅ + метрики улучшились → merge
   - Если нет → откатить, записать в journal

7. ПРИМЕНЕНИЕ
   - Merge в master
   - Обновление CHANGELOG.md
   - Обновление system-journal.md

8. ПОВТОР ЦИКЛА

┌─────────────────────────────────────────┐
│ git commit                              │
└─────────────────────────────────────────┘
                ↓
┌─────────────────────────────────────────┐
│ GitHub Actions (опционально)            │
│ - Lint (flake8)                         │
│ - Tests (pytest)                        │
│ - Coverage check                        │
└─────────────────────────────────────────┘
                ↓
┌─────────────────────────────────────────┐
│ DeployAgent                             │
│ - SSH на staging сервер                 │
│ - Деплой через Docker                   │
│ - Health check                          │
└─────────────────────────────────────────┘
                ↓
┌─────────────────────────────────────────┐
│ MonitorAgent                            │
│ - 24h мониторинг staging                │
│ - Сбор метрик                           │
└─────────────────────────────────────────┘
                ↓
┌─────────────────────────────────────────┐
│ Ручное подтверждение (если OK)          │
└─────────────────────────────────────────┘
                ↓
┌─────────────────────────────────────────┐
│ DeployAgent → production                │
└─────────────────────────────────────────┘

MonitorAgent обнаружил ошибку
    ↓
Алерт → BugfixAgent
    ↓
BugfixAgent анализирует
    ↓
    ├─ Простая ошибка → Генерирует патч → TestAgent → GitAgent
    │                                                      ↓
    │                                              system-journal.md
    │
    └─ Сложная ошибка → Эскалация → CentralAgent
                                        ↓
                                  Уведомление → ПОЛЬЗОВАТЕЛЬ
                                        ↓
                            Пользователь принимает решение

Основной язык: Python 3.11+
Альтернативы:
  - Bash (для скриптов инфраструктуры)
  - JavaScript (для E2E тестов Playwright)

Package manager: pip / poetry
Virtual environments: venv / pyenv

Core:
  - anthropic: ^0.40.0        # Claude API
  - pyyaml: ^6.0              # Конфигурация
  - click: ^8.1.0             # CLI
  - pathlib: built-in         # Файловая система

Development:
  - pytest: ^8.0.0            # Тестирование
  - pytest-cov: ^4.1.0        # Coverage
  - playwright: ^1.40.0       # E2E тесты
  - flake8: ^7.0.0            # Linting (опционально)

Agents (по мере необходимости):
  - docker: ^7.0.0            # DeployAgent
  - paramiko: ^3.4.0          # SSH для DeployAgent
  - psutil: ^5.9.0            # MonitorAgent
  - requests: ^2.31.0         # HTTP checks
  - openai: ^1.0.0            # Whisper API (VoiceAgent)
  - elevenlabs: ^0.2.0        # TTS (VoiceAgent)
  - pyaudio: ^0.2.14          # Audio capture (VoiceAgent)

Storage:
  - sqlite3: built-in         # Метрики (опционально)

Claude API:
  - Provider: Anthropic
  - Model: claude-sonnet-4-5-20250929
  - Pricing: $3/1M input tokens, $15/1M output tokens
  - Rate limits: По тарифному плану

Whisper API:
  - Provider: OpenAI
  - Purpose: Speech-to-Text
  - Pricing: $0.006/minute
  - Accuracy: ~95%+

ElevenLabs API:
  - Provider: ElevenLabs
  - Purpose: Text-to-Speech
  - Pricing: ~$0.30/1000 characters
  - Voices: 10+ голосов (русский язык поддерживается)

Version Control:
  - Git: монорепозиторий
  - GitHub / GitLab (опционально для backup)

Servers:
  - SSH доступ: passwordless (ключи)
  - Docker: 20.10+ для деплоя
  - systemd: для сервисов

CI/CD (опционально):
  - GitHub Actions
  - GitLab CI
  - Self-hosted runners

Pattern: Микросервисная архитектура
Implementation:
  - Каждый агент = независимый класс
  - Взаимодействие через AgentAPI (hub)
  - Loose coupling, high cohesion

Преимущества:
  + Легко добавлять новые агенты
  + Независимое тестирование
  + Горизонтальное масштабирование (в будущем)

Pattern: Chain of Responsibility + Cache
Implementation:
  - 7 уровней поиска (L1-L7)
  - Каждый уровень проверяется последовательно
  - При нахождении — прерывание цепочки

Преимущества:
  + Экономия tokens (80-86%)
  + Переиспользование кода
  + Консистентность

class BaseAgent(ABC):
    def __init__(self, name, workspace):
        # Общая инициализация
        pass

    @abstractmethod
    def execute(self, task):
        # Каждый агент реализует сам
        pass

    def call_claude(self, prompt):
        # Общий метод
        pass

# Template Method pattern:
# - Общая структура в базовом классе
# - Специфика в наследниках

class CascadeSearch:
    def __init__(self):
        self.strategies = [
            L1_PlatformRules(),
            L2_Registry(),
            L3_Templates(),
            L4_Components(),
            L5_Projects(),
            L6_Archive(),
            L7_Generate()
        ]

    def search(self, query):
        for strategy in self.strategies:
            result = strategy.search(query)
            if result.found:
                return result
        return None

# Strategy pattern:
# - Разные стратегии поиска
# - Легко добавить новый уровень

class MonitorAgent:
    def __init__(self):
        self.observers = []  # BugfixAgent, MetaAgent, etc.

    def subscribe(self, observer):
        self.observers.append(observer)

    def notify_error(self, error):
        for observer in self.observers:
            observer.on_error(error)

# Observer pattern:
# - MonitorAgent уведомляет подписчиков
# - Слабая связанность

class AgentAPI:
    def create_agent(self, agent_type):
        if agent_type == "DocumentAgent":
            return DocumentAgent(workspace)
        elif agent_type == "CodeAgent":
            return CodeAgent(workspace)
        # ...

# Factory pattern:
# - Централизованное создание агентов
# - Упрощение регистрации

# Формат задачи (JSON-like dict)
{
    "type": "название_задачи",
    "params": {
        "param1": "value1",
        "param2": "value2"
    },
    "priority": "high|normal|low",
    "timeout": 300  # секунды
}

# Формат ответа
{
    "status": "success|error|partial",
    "result": {...},
    "agent": "AgentName",
    "execution_time": 12.5,  # секунды
    "tokens_used": 1234,
    "error": None  # или сообщение об ошибке
}

# Через anthropic-sdk
response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=4096,
    system="Ты — агент X платформы ЦИФРА...",
    messages=[{
        "role": "user",
        "content": "Промпт для задачи..."
    }]
)

# Метрики сохраняются для Token Economy

# Speech-to-Text (Whisper)
audio_file = open("recording.wav", "rb")
transcript = openai.Audio.transcribe(
    model="whisper-1",
    file=audio_file,
    language="ru"
)

# Text-to-Speech (ElevenLabs)
from elevenlabs import generate, play

audio = generate(
    text="Ответ пользователю",
    voice="Anton",  # Русский голос
    model="eleven_multilingual_v2"
)
play(audio)

# SSH через paramiko
ssh = paramiko.SSHClient()
ssh.connect(hostname, username, key_filename)
stdin, stdout, stderr = ssh.exec_command("docker ps")

# Docker SDK
import docker
client = docker.from_env()
container = client.containers.run(
    "myimage:latest",
    detach=True,
    ports={'8501/tcp': 8501}
)

# .env файл (НЕ коммитится в Git)
ANTHROPIC_API_KEY=sk-ant-...
OPENAI_API_KEY=sk-...
ELEVENLABS_API_KEY=...
SSH_KEY_PATH=/root/.ssh/id_rsa

# Загрузка через python-dotenv
from dotenv import load_dotenv
load_dotenv()

# Перед выполнением команд
def validate_command(cmd):
    FORBIDDEN = ["rm -rf /", "DROP DATABASE", "format C:"]
    if any(forbidden in cmd for forbidden in FORBIDDEN):
        raise SecurityError("Forbidden command!")

Агенты выполняются в изолированных окружениях:
- Docker контейнеры для CodeAgent генерации
- chroot для тестирования
- Network isolation

Структура:
  id: UUID (генерируется автоматически)
  name: str (уникальное имя проекта)
  template: str (шаблон, из которого создан)
  created_at: datetime
  updated_at: datetime
  status: enum(active, archived, deprecated)

Файлы:
  - projects/{name}/design/PROJECT.md
  - projects/{name}/design/ROADMAP.md
  - projects/{name}/design/ARCHITECTURE.md
  - projects/{name}/management/README.md
  - projects/{name}/management/CHANGELOG.md
  - projects/{name}/solution/  (код)
  - projects/{name}/infrastructure/  (серверы)

Связи:
  - Создан из Template (1:1)
  - Содержит N решений (solution/)
  - Развёрнут на M серверах (infrastructure/)

Структура:
  name: str (уникальное имя)
  version: semver (MAJOR.MINOR.PATCH)
  category: enum(by-feature, by-task, library)
  description: str
  variables: list[Variable]
  dependencies: list[str]

Файлы:
  - templates/{category}/{name}/template.yaml
  - templates/{category}/{name}/README.md
  - templates/{category}/{name}/CHANGELOG.md
  - templates/{category}/{name}/structure/  (файлы шаблона)

Связи:
  - Версии (1:N) через CHANGELOG.md
  - Используется проектами (N:M)

Структура:
  path: str (путь к файлу)
  type: enum(formatter, validator, model, service)
  language: enum(python, bash, js)
  description: str
  usage_count: int (сколько раз использован)

Файлы:
  - components/{layer}/{domain}/{component}.py
  - components/catalog.yaml  (реестр)

Связи:
  - Используется в проектах (N:M)
  - Найден через Cascade Search (L4)

Структура:
  name: str (уникальное имя)
  type: enum(core, lifecycle, meta, interface)
  status: enum(active, inactive, deprecated)
  created_at: datetime
  version: semver

Файлы:
  - platform/agents/{name}.py
  - platform/docs/{name}.md
  - platform/.claude/agents/{name}_context.yaml

Данные в runtime:
  - context: dict (текущий контекст агента)
  - metrics: dict (производительность)

Связи:
  - Координируется через CentralAgent
  - Регистрирован в AgentAPI

Структура:
  id: UUID
  type: str (тип задачи)
  agent: str (какой агент выполняет)
  params: dict (параметры)
  status: enum(pending, running, completed, failed)
  created_at: datetime
  started_at: datetime
  completed_at: datetime
  result: dict

Хранение:
  - В памяти (runtime)
  - Логируется в .claude/session-*.md

Связи:
  - Создана пользователем или агентом
  - Выполняется агентом
  - Часть workflow

Структура:
  name: str (например, "create_project")
  steps: list[Step]
  status: enum(running, completed, failed)

Step:
  agent: str
  task: Task
  dependencies: list[str]  (какие шаги должны завершиться перед этим)

Хранение:
  - Определены в CentralAgent.workflows
  - Логируются в system-journal.md

Структура:
  timestamp: datetime
  agent: str
  operation: str
  execution_time: float  (секунды)
  tokens_input: int
  tokens_output: int
  tokens_cached: int
  success: bool
  error: str | None

Хранение:
  - SQLite (опционально)
  - CSV файлы (для простоты)
  - platform/.claude/metrics/YYYY-MM-DD.csv

Используется:
  - Token Economy отчёты
  - MetaAgent анализ

User Input
    ↓ (голос/текст)
VoiceAgent
    ↓ (текст команды)
CentralAgent.parse()
    ↓ (Task объект)
ProjectAgent.execute()
    ↓ (читает)
templates/{template}/template.yaml
    ↓ (копирует)
projects/{name}/  (файловая структура)
    ↓
DocumentAgent.execute()
    ↓ (читает примеры)
projects/marketplace/design/PROJECT.md
    ↓ (генерирует через Claude API)
projects/{name}/design/PROJECT.md
    ↓
CodeAgent.execute()
    ↓ (Cascade Search)
templates/, components/
    ↓ (копирует и адаптирует)
projects/{name}/solution/
    ↓
GitAgent.execute()
    ↓ (commit)
.git/
    ↓ (обновляет)
platform/.claude/system-journal.md
    ↓
Result → User

Agent вызывает Claude API
    ↓
anthropic SDK возвращает response
    ↓
response.usage {
    input_tokens: 1234,
    output_tokens: 567,
    cache_read_tokens: 890
}
    ↓
Agent логирует в metrics
    ↓
platform/.claude/metrics/YYYY-MM-DD.csv
    ↓ (агрегация)
Token Economy отчёт
    ↓
ROI расчёт:
  cost_saved = (tokens_without_cascade - tokens_with_cascade) * price
  roi = cost_saved / development_cost

MetaAgent.schedule (каждые N дней)
    ↓ (читает)
platform/.claude/metrics/*.csv
    ↓ (анализирует)
Git history (git log --stat)
    ↓ (находит паттерны через Claude API)
Частый дублируемый код → candidate для components/
    ↓ (генерирует)
Улучшение (например, новый компонент)
    ↓ (тестирует)
pytest tests/ (все тесты)
    ↓ (если OK)
CodeAgent создаёт components/{new_component}.py
    ↓
GitAgent commit "refactor: extracted {component}"
    ↓ (обновляет)
components/catalog.yaml
    ↓ (теперь доступен)
Cascade Search L4

/opt/claude-workspace/
├── platform/
│   ├── .claude/
│   │   ├── system-journal.md        # История событий
│   │   ├── session-*.md             # Сессии
│   │   └── metrics/
│   │       └── YYYY-MM-DD.csv       # Метрики по дням
│   └── *.md                         # Документация
│
├── templates/
│   └── */template.yaml              # Метаданные шаблонов
│
├── components/
│   └── catalog.yaml                 # Реестр компонентов
│
└── projects/
    └── */
        ├── design/*.md              # Проектные документы
        ├── management/*.md          # README, CHANGELOG
        └── solution/                # Код

.git/
├── objects/     # Все версии файлов
├── refs/        # Ветки, теги
└── logs/        # История коммитов

Используется:
- BugfixAgent анализирует историю
- GitAgent управляет версиями
- MetaAgent анализирует изменения

CREATE TABLE metrics (
    id INTEGER PRIMARY KEY,
    timestamp DATETIME,
    agent TEXT,
    operation TEXT,
    execution_time REAL,
    tokens_input INTEGER,
    tokens_output INTEGER,
    success BOOLEAN
);

CREATE TABLE components_usage (
    component TEXT,
    project TEXT,
    used_at DATETIME
);

# platform/config/agents.yaml
agents:
  DocumentAgent:
    enabled: true
    timeout: 300
  CodeAgent:
    enabled: true
    cascade_levels: [L1, L2, L3, L4, L5, L6, L7]

# components/catalog.yaml
formatters:
  - name: format_price
    path: components/shared/lib/formatters.py
    usage_count: 45

# Platform rules кэшируются (префикс в system prompt)
system = """
<platform_rules>
{content of platform/CLAUDE.md}  # ← Кэшируется автоматически
</platform_rules>

Ты — агент X...
"""

# Экономия:
# - Input tokens снижаются на 90% при повторных вызовах
# - Cache read tokens = $0.30/1M (в 10 раз дешевле)

Cascade Search САМ ПО СЕБЕ = кэш существующих решений!

L3-L6 = "кэш" готового кода
L7 = генерация (если кэш промахнулся)

# Кэширование результатов CodeAgent
cache_dir = "platform/.claude/cache/"

def cached_generate(prompt):
    cache_key = hashlib.md5(prompt.encode()).hexdigest()
    cache_file = cache_dir + cache_key + ".txt"

    if os.path.exists(cache_file):
        return open(cache_file).read()  # Кэш попадание

    result = claude_api.generate(prompt)  # Генерация
    open(cache_file, 'w').write(result)   # Сохранить в кэш
    return result

2025-11-09: ДЕНЬ 1 — Инициализация
    - Создана структура workspace
    - Реализована каскадная система правил
    - Созданы принципы из AI Platform v3.9.6
    - Создан platform/CLAUDE.md
    - Git настроен как монорепозиторий
    - Backup: /opt/workspace-backup-20251109-060708.tar.gz
    Результат: ✅ Workspace v1.0.0

2025-11-10: ДЕНЬ 2 — Инфраструктура
    - Components Library (FSD): 4 компонента, экономия 4,500 tokens
    - Templates Library: 3 шаблона, экономия 10,700 tokens
    - Tests Library: 8 тестов, экономия 15,900 tokens
    - Versioning System: VERSIONS.yaml, semantic versioning
    - Streamlit Documentation: 688 строк
    - PLATFORM_OVERVIEW.md: главный документ для контекста
    Результат: ✅ 11 коммитов, 48 файлов, ~9,000 строк

2025-11-10: ДЕНЬ 2 (продолжение) — Планирование
    - DEVELOPMENT_SEQUENCE.md: план на 5 фаз
    - Мульти-агентная архитектура спроектирована
    - Bootstrap подход определён
    - Технологический стек выбран
    Результат: ✅ Blueprint готов к реализации

Сроки: 1-2 дня
Цель: Создать 3 базовых агента вручную

Этапы:
День 1:
  - Создать BaseAgent
  - Реализовать DocumentAgent
  - Реализовать CodeAgent (с Cascade Search)
  - Реализовать GitAgent
  - Создать AgentAPI

День 2:
  - Написать тесты (pytest)
  - Создать bootstrap.py
  - Протестировать end-to-end
  - Git commit "feat: Bootstrap агенты готовы"

Критерии завершения:
  ✅ 3 агента работают
  ✅ AgentAPI позволяет вызывать агентов
  ✅ Все тесты проходят
  ✅ Можно создать простой PROJECT.md через DocumentAgent

Сроки: 2-3 дня
Цель: 3 агента создают новых агентов

Этапы:
День 3:
  - Написать спецификацию ProjectAgent
  - CodeAgent генерирует код ProjectAgent
  - DocumentAgent создаёт docs/ProjectAgent.md
  - TestAgent создаётся аналогично

День 4:
  - Интеграция новых агентов
  - Тестирование самосоздания
  - Проверка концепции

День 5 (резерв):
  - Исправление багов
  - Оптимизация

Критерии завершения:
  ✅ ProjectAgent создан ЧЕРЕЗ CodeAgent (не вручную!)
  ✅ TestAgent создан аналогично
  ✅ 5 агентов работают
  ✅ Концепция bootstrap доказана

Сроки: 1-2 дня
Цель: Координация агентов через CentralAgent

Этапы:
День 6:
  - Создать CentralAgent
  - Реализовать WorkflowEngine
  - Workflow "create_project"

День 7:
  - CLI интерфейс (Click)
  - Тестирование end-to-end workflow
  - Документация

Критерии завершения:
  ✅ CentralAgent координирует агентов
  ✅ Можно создать проект одной командой: `cli create-project --name X`
  ✅ CLI работает

Сроки: 3-5 дней
Цель: Покрытие полного цикла разработки

Этапы:
День 8-9:
  - DeployAgent (Docker SDK, SSH)
  - MonitorAgent (health checks, psutil)

День 10-11:
  - BugfixAgent (анализ ошибок, патчи)
  - Интеграция с существующей инфраструктурой

День 12 (резерв):
  - Тестирование на реальных проектах
  - Исправление багов

Критерии завершения:
  ✅ Полный цикл: create → deploy → monitor → bugfix работает
  ✅ Протестировано на marketplace проекте
  ✅ 9 агентов работают

Сроки: 3-5 дней
Цель: Платформа улучшает саму себя

Этапы:
День 13-14:
  - MetaAgent (анализ метрик)
  - AnalyticsAgent (сбор данных)

День 15-16:
  - Реализация цикла самосовершенствования
  - Тестирование улучшений

День 17 (резерв):
  - Проверка безопасности
  - Ограничения для MetaAgent

Критерии завершения:
  ✅ MetaAgent находит паттерны
  ✅ Автоматически создаёт компоненты из дублируемого кода
  ✅ Проверено хотя бы 1 автоматическое улучшение

Сроки: 5-7 дней
Цель: Голосовое управление платформой

Этапы:
День 18-19:
  - VoiceAgent (PyAudio, Whisper API)
  - STT (Speech-to-Text)

День 20-21:
  - TTS (Text-to-Speech, ElevenLabs)
  - NLU (понимание команд через Claude)

День 22-24:
  - Интеграция с CentralAgent
  - Тестирование на русском языке
  - UI для голосового ввода (опционально)

Критерии завершения:
  ✅ Можно создать проект голосом
  ✅ Платформа озвучивает результаты
  ✅ NLU понимает русские команды

MAJOR.MINOR.PATCH

MAJOR:
  - Изменение архитектуры (breaking changes)
  - Несовместимые изменения API
  - Пример: 1.0.0 → 2.0.0 (добавление агентов)

MINOR:
  - Новая функциональность (backwards compatible)
  - Новый агент
  - Пример: 1.0.0 → 1.1.0 (добавлен VoiceAgent)

PATCH:
  - Исправление багов
  - Улучшение производительности
  - Пример: 1.0.0 → 1.0.1 (исправлен баг в CodeAgent)

v1.0.0 (2025-11-09) — Initial workspace
  - Cascade Search
  - Templates + Components
  - Token Economy
  - Documentation

v1.1.0 (2025-11-15) — Bootstrap agents
  - DocumentAgent
  - CodeAgent
  - GitAgent
  - AgentAPI

v1.2.0 (2025-11-18) — Self-creation
  - ProjectAgent
  - TestAgent
  - Bootstrap концепция

v1.3.0 (2025-11-20) — Coordination
  - CentralAgent
  - WorkflowEngine
  - CLI

v2.0.0 (2025-11-25) — Full lifecycle
  - DeployAgent
  - MonitorAgent
  - BugfixAgent
  - BREAKING: новая архитектура агентов

v2.1.0 (2025-11-30) — Meta
  - MetaAgent
  - AnalyticsAgent
  - Самосовершенствование

v2.2.0 (2025-12-07) — Voice
  - VoiceAgent
  - Whisper + ElevenLabs
  - NLU

Понедельник:
  - Обзор метрик за неделю
  - Анализ Token Economy
  - Планирование задач

Вторник-Четверг:
  - Разработка новых агентов/функций
  - Исправление багов
  - Тестирование

Пятница:
  - Code review (через MetaAgent)
  - Обновление документации
  - Git tag для версии

Выходные:
  - MetaAgent анализирует неделю
  - Генерирует улучшения
  - Тестирует их

1-я неделя: Новая функциональность (новые агенты)
2-я неделя: Рефакторинг (MetaAgent)
3-я неделя: Оптимизация (производительность)
4-я неделя: Документация + тестирование

1. Объявление deprecation (MINOR версия):
   - Агент/функция помечается @deprecated
   - Документация обновляется
   - Логирование предупреждений

2. Период поддержки (минимум 1 MAJOR версия):
   - Функциональность продолжает работать
   - Новые проекты не используют deprecated

3. Удаление (следующая MAJOR версия):
   - Код перемещается в archive/
   - Обновляется MIGRATION.md
   - Git tag для last working version

Пример:
  v2.0.0: OldAgent помечен @deprecated
  v2.1.0-2.9.0: OldAgent всё ещё работает (warning)
  v3.0.0: OldAgent удалён, код в archive/deprecated/

Имя: xirfbwpmvt.vps.hosting
IP: 91.218.142.168
Роль: Управляющий сервер
OS: Linux 5.15.0-160-generic

Размещено:
  ✅ /opt/claude-workspace/ (вся платформа)
  ✅ Claude Code (этот сервер)
  ✅ Агенты (когда будут созданы)
  ✅ Git репозиторий
  ✅ Документация

НЕ размещено:
  ❌ Production приложения (они на Сервере 2)
  ❌ Базы данных приложений

Имя: leruepecie.vps.hosting
IP: 45.144.177.147
Роль: Production Docker платформа
SSH: passwordless доступ с Сервера 1

Размещено:
  ✅ 34 Docker контейнера
  ✅ seller1.ru (КРИТИЧНЫЙ production сервис)
  ✅ Development окружения
  ✅ 14 доменов с SSL

Управляется:
  - DeployAgent (с Сервера 1 через SSH)
  - MonitorAgent (проверки с Сервера 1)

Claude API:
  - Anthropic серверы (США)
  - HTTPS соединение
  - Используется всеми агентами

Whisper API:
  - OpenAI серверы
  - Для VoiceAgent

ElevenLabs API:
  - ElevenLabs серверы
  - Для VoiceAgent

Git Remote (опционально):
  - GitHub / GitLab
  - Backup репозитория

┌────────────────────────────────────────────────┐
│ СЕРВЕР 1 (Control Plane)                      │
│ 91.218.142.168                                 │
│                                                │
│ ┌────────────────────────────────────────┐    │
│ │ /opt/claude-workspace/                 │    │
│ │                                        │    │
│ │ ┌──────────────────┐                  │    │
│ │ │ Platform         │                  │    │
│ │ │ - Agents         │                  │    │
│ │ │ - AgentAPI       │                  │    │
│ │ │ - Cascade Search │                  │    │
│ │ └──────────────────┘                  │    │
│ │                                        │    │
│ │ ┌──────────────────┐                  │    │
│ │ │ Templates        │                  │    │
│ │ │ Components       │                  │    │
│ │ │ Tests            │                  │    │
│ │ └──────────────────┘                  │    │
│ │                                        │    │
│ │ ┌──────────────────┐                  │    │
│ │ │ Projects         │                  │    │
│ │ │ - marketplace    │                  │    │
│ │ │ - ...            │                  │    │
│ │ └──────────────────┘                  │    │
│ └────────────────────────────────────────┘    │
│                                                │
│ ┌────────────────────────────────────────┐    │
│ │ .git/                                  │    │
│ │ - Монорепозиторий                      │    │
│ │ - Вся история                          │    │
│ └────────────────────────────────────────┘    │
└────────────────────────────────────────────────┘
                      ↓ SSH
┌────────────────────────────────────────────────┐
│ СЕРВЕР 2 (Production Platform)                │
│ 45.144.177.147                                 │
│                                                │
│ ┌────────────────────────────────────────┐    │
│ │ Docker Stacks                          │    │
│ │ - seller1-prod-stack (4 containers)    │    │
│ │ - npm-stack (nginx proxy manager)      │    │
│ │ - monitoring-stack (uptime kuma)       │    │
│ │ - ...                                  │    │
│ └────────────────────────────────────────┘    │
└────────────────────────────────────────────────┘
                      ↓ HTTPS
┌────────────────────────────────────────────────┐
│ INTERNET                                       │
│ - Users → https://seller1.ru                   │
│ - Users → https://npm.0kt.ru                   │
└────────────────────────────────────────────────┘

localhost (127.0.0.1):
  - Агенты взаимодействуют через AgentAPI
  - Нет сетевых вызовов (всё в одном процессе)
  - Файловая система: /opt/claude-workspace/

91.218.142.168 → SSH → 45.144.177.147:22

DeployAgent:
  ssh root@45.144.177.147 "docker ps"

MonitorAgent:
  ssh root@45.144.177.147 "curl -I http://localhost:8501"

91.218.142.168 → HTTPS → api.anthropic.com:443
  - Claude API вызовы
  - Все агенты используют

91.218.142.168 → HTTPS → api.openai.com:443
  - Whisper API (VoiceAgent)

91.218.142.168 → HTTPS → api.elevenlabs.io:443
  - Text-to-Speech (VoiceAgent)

Internet → HTTPS → 45.144.177.147:443
  - seller1.ru (production app)
  - npm.0kt.ru (nginx proxy manager)
  - home.0kt.ru, git.0kt.ru, etc.

/opt/claude-workspace/
├── platform/              [5 MB]
│   ├── CLAUDE.md
│   ├── PLATFORM_OVERVIEW.md
│   ├── DEVELOPMENT_SEQUENCE.md
│   └── .claude/
│       ├── system-journal.md
│       ├── metrics/       [растёт: 1KB/день]
│       └── session-*.md   [1KB/сессия]
│
├── templates/             [10 MB]
│   └── */
│
├── components/            [2 MB]
│   └── */
│
├── tests/                 [5 MB]
│   └── */
│
├── projects/              [переменный, зависит от количества]
│   └── marketplace/       [50 MB]
│
└── .git/                  [100 MB, растёт]

ИТОГО: ~172 MB (текущее)
Прогноз через 1 год: ~500 MB

/var/lib/docker/volumes/   [переменный]
├── seller1_postgres/      [500 MB]
├── seller1_redis/         [50 MB]
├── npm_data/              [100 MB]
└── ...

ИТОГО: ~5-10 GB (зависит от приложений)

Claude API:
  - НЕТ постоянного хранения
  - Только API вызовы

Git Remote (если настроен):
  - Копия всего репозитория
  - ~172 MB (синхронизируется)

# Автоматический backup (cron: ежедневно в 3:00)
cd /opt/claude-workspace
tar -czf /opt/workspace-backup-$(date +%Y%m%d).tar.gz .

Расположение: /opt/workspace-backup-*.tar.gz
Хранение: 7 дней (старые удаляются)
Размер: ~50 MB (сжато)

# После каждого значимого изменения
git add .
git commit -m "..."
git push origin master  # Если настроен remote

Remote: GitHub / GitLab (опционально)
Хранение: вся история (навсегда)

# Backup баз данных (скрипт на Сервере 2)
docker exec seller1_postgres pg_dump > /backup/seller1-$(date +%Y%m%d).sql

Расположение: /backup/ на Сервере 2
Хранение: 30 дней
Размер: зависит от данных

# 1. Восстановление workspace
cd /
tar -xzf /opt/workspace-backup-YYYYMMDD.tar.gz -C /opt/claude-workspace/

# 2. Проверка Git
cd /opt/claude-workspace
git status
git log -1  # Последний коммит

# 3. Восстановление production (если нужно)
ssh root@45.144.177.147
docker exec -i seller1_postgres psql < /backup/seller1-YYYYMMDD.sql

Текущее:
  - CPU: 2 core
  - RAM: 4 GB
  - SSD: 50 GB

При необходимости:
  - CPU: 4-8 core (для параллельных агентов)
  - RAM: 8-16 GB (для кэширования)
  - SSD: 100 GB (для метрик и истории)

┌────────────────────┐
│ Load Balancer      │
└────────────────────┘
     ↓        ↓        ↓
┌─────────┐ ┌─────────┐ ┌─────────┐
│ Agent   │ │ Agent   │ │ Agent   │
│ Node 1  │ │ Node 2  │ │ Node 3  │
└─────────┘ └─────────┘ └─────────┘
     ↓        ↓        ↓
┌────────────────────────────┐
│ Shared Storage (NFS/S3)    │
│ /opt/claude-workspace/     │
└────────────────────────────┘

CentralAgent (Координатор)
    ↓
Message Queue (RabbitMQ / Redis)
    ↓
    ├→ DocumentAgent (Node 1)
    ├→ CodeAgent (Node 2)
    ├→ TestAgent (Node 3)
    └→ DeployAgent (Node 4)