blockmine 1.24.0 → 1.25.0

package/.claude/skills/node-development/SKILL.md

@@ -1,317 +0,0 @@
----
-name: node-development
-description: Создание нод для визуального редактора BlockMine. Используй при создании новых нод, исправлении ошибок в нодах, работе с executor/evaluator, helpers, регистрацией нод на backend и frontend.
----
-
-# Node Development - Визуальный редактор BlockMine
-
-## Архитектура нод
-
-Ноды состоят из двух частей:
-- **Backend** - логика выполнения (executor/evaluator)
-- **Frontend** - визуальное представление (NodeDefinition)
-
-## Типы нод
-
-### 1. Action Node (с exec пинами)
-- Имеет входной `exec` пин и выходные `exec`/`exec_failed` пины
-- Использует **executor** для выполнения действий
-- Может иметь **evaluator** для data-выходов
-
-### 2. Data Node (без exec пинов)
-- Только data-пины (Number, String, Boolean, Object, Array)
-- Использует только **evaluator**
-- Вычисляет значения по запросу
-
----
-
-## Backend: Структура файлов
-
-```
-backend/src/core/
-├── nodes/{category}/{node_name}.js      # Логика ноды
-├── node-registries/{category}.js        # Регистрация нод категории
-└── constants/graphTypes.js              # Типы графов
-```
-
----
-
-## Backend: Executor (Action ноды)
-
-```javascript
-async function execute(node, context, helpers) {
-  const { resolvePinValue, traverse, memo } = helpers;
-  const bot = context.bot;
-
-  // Получить значение входного пина (с fallback на node.data)
-  const value = await resolvePinValue(node, 'pinName', node.data?.pinName);
-
-  try {
-    // Выполнить действие...
-    const result = await bot.someAction();
-
-    // Сохранить результаты для data-выходов
-    memo.set(`${node.id}:outputPin`, result);
-    memo.set(`${node.id}:success`, true);
-
-    // Перейти к следующей ноде (успех)
-    await traverse(node, 'exec');
-  } catch (error) {
-    memo.set(`${node.id}:success`, false);
-    // Перейти к exec_failed
-    await traverse(node, 'exec_failed');
-  }
-}
-
-module.exports = { execute };
-```
-
----
-
-## Backend: Evaluator (Data ноды и data-выходы)
-
-```javascript
-async function evaluate(node, pinId, context, helpers) {
-  const { resolvePinValue, memo } = helpers;
-  const bot = context.bot;
-
-  // Получить входные значения
-  const inputValue = await resolvePinValue(node, 'inputPin');
-
-  // Вернуть значение для запрошенного пина
-  if (pinId === 'outputPin') {
-    return computedValue;
-  }
-
-  // Для action нод - читать из memo
-  if (pinId === 'success') {
-    return memo.get(`${node.id}:success`) ?? false;
-  }
-
-  return null;
-}
-
-module.exports = { evaluate };
-```
-
----
-
-## ВАЖНО: Правильные helpers
-
-```javascript
-// ПРАВИЛЬНО:
-await helpers.resolvePinValue(node, 'pinName');
-await helpers.resolvePinValue(node, 'pinName', defaultValue);
-
-// НЕПРАВИЛЬНО (не существует!):
-await helpers.resolveInput(node.id, 'pinName');  // НЕ РАБОТАЕТ!
-```
-
-### Helpers в Executor:
-- `resolvePinValue(node, pinId, defaultValue?)` - получить значение пина
-- `traverse(node, execPinId)` - перейти к следующей ноде
-- `memo` - Map для хранения результатов
-- `clearLoopBodyMemo(loopNodeId)` - очистить memo тела цикла
-
-### Helpers в Evaluator:
-- `resolvePinValue(node, pinId, defaultValue?)` - получить значение пина
-- `memo` - Map для чтения результатов
-
----
-
-## Backend: Регистрация ноды
-
-```javascript
-// backend/src/core/node-registries/{category}.js
-const { GRAPH_TYPES } = require('../constants/graphTypes');
-
-function registerNodes(registry) {
-  // Action нода (с exec)
-  registry.registerNodeType({
-    type: 'category:node_name',
-    label: '🔥 Название',
-    category: 'Категория',
-    description: 'Описание ноды',
-    graphType: GRAPH_TYPES.ALL,
-    executor: require('../nodes/category/node_name').execute,
-    evaluator: require('../nodes/category/node_name').evaluate, // опционально
-    pins: {
-      inputs: [
-        { id: 'exec', name: 'Выполнить', type: 'Exec' },
-        { id: 'inputPin', name: 'Вход', type: 'String', required: true },
-      ],
-      outputs: [
-        { id: 'exec', name: 'Готово', type: 'Exec' },
-        { id: 'exec_failed', name: 'Ошибка', type: 'Exec' },
-        { id: 'result', name: 'Результат', type: 'Object' },
-        { id: 'success', name: 'Успех?', type: 'Boolean' },
-      ]
-    }
-  });
-
-  // Data нода (без exec)
-  registry.registerNodeType({
-    type: 'category:data_node',
-    label: '📊 Название',
-    category: 'Категория',
-    description: 'Описание',
-    graphType: GRAPH_TYPES.ALL,
-    evaluator: require('../nodes/category/data_node').evaluate,
-    pins: {
-      inputs: [
-        { id: 'input', name: 'Вход', type: 'String', required: true },
-      ],
-      outputs: [
-        { id: 'output', name: 'Выход', type: 'String' },
-      ]
-    }
-  });
-}
-
-module.exports = { registerNodes };
-```
-
----
-
-## Frontend: Структура файлов
-
-```
-frontend/src/components/visual-editor/nodes/
-├── {category}/
-│   ├── {nodeName}.js           # NodeDefinition
-│   ├── {NodeName}Settings.jsx  # Компонент настроек (опционально)
-│   └── index.js                # Экспорты категории
-└── index.js                    # Регистрация всех нод
-```
-
----
-
-## Frontend: NodeDefinition
-
-```javascript
-// frontend/src/components/visual-editor/nodes/{category}/{nodeName}.js
-import { NodeDefinition } from '../../core/registry';
-import NodeNameSettings from './NodeNameSettings'; // опционально
-
-export const nodeNameDefinition = new NodeDefinition({
-  type: 'category:node_name',  // Должен совпадать с backend!
-  category: 'category',
-  label: '🔥 Название',
-  description: 'Описание ноды',
-
-  computeInputs: (data) => [
-    { id: 'exec', name: 'Выполнить', type: 'Exec' },
-    {
-      id: 'inputPin',
-      name: 'Вход',
-      type: 'String',
-      required: true,
-      inlineField: true,        // Поле ввода прямо в ноде
-      placeholder: 'значение',
-      description: 'Подсказка при наведении'
-    },
-  ],
-
-  computeOutputs: (data) => [
-    { id: 'exec', name: 'Готово', type: 'Exec' },
-    { id: 'exec_failed', name: 'Ошибка', type: 'Exec' },
-    { id: 'result', name: 'Результат', type: 'Object' },
-  ],
-
-  SettingsComponent: NodeNameSettings, // опционально
-
-  defaultData: {
-    inputPin: '',
-  },
-
-  theme: {
-    headerColor: '#d97706',  // Цвет заголовка
-    accentColor: '#f59e0b',  // Акцентный цвет
-  },
-});
-```
-
----
-
-## Frontend: Settings компонент (опционально)
-
-```jsx
-// frontend/src/components/visual-editor/nodes/{category}/{NodeName}Settings.jsx
-import React, { useState } from 'react';
-import { Button } from '@/components/ui/button';
-import CoordinatePickerDialog from '@/components/minecraft/CoordinatePickerDialog';
-
-const NodeNameSettings = ({ nodeId, data, updateNodeData }) => {
-  const [pickerOpen, setPickerOpen] = useState(false);
-
-  const handleSelect = (coords) => {
-    updateNodeData(nodeId, {
-      x: coords.x,
-      y: coords.y,
-      z: coords.z,
-    });
-  };
-
-  return (
-    <div className="p-2 border-t border-slate-700">
-      <Button onClick={() => setPickerOpen(true)}>
-        Выбрать координаты
-      </Button>
-      <CoordinatePickerDialog
-        open={pickerOpen}
-        onClose={() => setPickerOpen(false)}
-        onSelect={handleSelect}
-        currentCoords={data}
-        targetBlock={true}
-      />
-    </div>
-  );
-};
-
-export default NodeNameSettings;
-```
-
----
-
-## Frontend: Регистрация
-
-```javascript
-// frontend/src/components/visual-editor/nodes/{category}/index.js
-export { nodeNameDefinition } from './nodeName';
-export { otherNodeDefinition } from './otherNode';
-
-// frontend/src/components/visual-editor/nodes/index.js
-import { nodeNameDefinition } from './category';
-
-export function registerAllNodes() {
-  NodeRegistry.register(nodeNameDefinition);
-  // ...
-}
-```
-
----
-
-## Типы пинов
-
-| Тип | Цвет | Описание |
-|-----|------|----------|
-| `Exec` | Белый | Поток выполнения |
-| `String` | Розовый | Строка |
-| `Number` | Синий | Число |
-| `Boolean` | Красный | true/false |
-| `Object` | Фиолетовый | Объект |
-| `Array` | Оранжевый | Массив |
-| `Wildcard` | Серый | Любой тип |
-
----
-
-## Чеклист создания ноды
-
-- [ ] Backend: создать `nodes/{category}/{name}.js` с execute/evaluate
-- [ ] Backend: добавить в `node-registries/{category}.js`
-- [ ] Frontend: создать `nodes/{category}/{name}.js` с NodeDefinition
-- [ ] Frontend: создать Settings компонент (если нужен)
-- [ ] Frontend: экспортировать в `nodes/{category}/index.js`
-- [ ] Frontend: зарегистрировать в `nodes/index.js`
-- [ ] Проверить что `type` совпадает на backend и frontend
-- [ ] Использовать `resolvePinValue(node, 'pin')` НЕ `resolveInput`

package/.claude/skills/observability-engineering/SKILL.md

@@ -1,101 +0,0 @@
-# Observability Engineering
-
-Deep dive into distributed tracing, APM tools, OpenTelemetry, logs aggregation, and observability best practices.
-
-## Purpose
-
-Enable teams to gain deep visibility into distributed systems with comprehensive observability practices beyond basic monitoring.
-
-## When to Use This Skill
-
-Automatically activates when working on:
-- Distributed tracing (Jaeger, Tempo, Zipkin)
-- OpenTelemetry instrumentation
-- APM tools (DataDog, New Relic, Dynatrace)
-- Logs aggregation (ELK, Loki)
-- Correlation strategies (trace IDs, unified observability)
-- Service mesh observability
-- Observability cost optimization
-
-## Quick Start Checklist
-
-- [ ] Instrument application with OpenTelemetry
-- [ ] Set up distributed tracing backend
-- [ ] Configure logs aggregation
-- [ ] Implement correlation (trace IDs across logs/metrics/traces)
-- [ ] Set up APM dashboards
-- [ ] Configure sampling strategies
-- [ ] Monitor observability costs
-- [ ] Create SLO-based alerts
-
-## Core Concepts
-
-### Three Pillars of Observability
-
-```
-Logs:    What happened (events)
-Metrics: How much (counters, gauges)
-Traces:  Where time was spent (distributed request flow)
-```
-
-### OpenTelemetry
-
-```typescript
-import { trace, context } from '@opentelemetry/api';
-
-const tracer = trace.getTracer('my-service');
-
-async function handleRequest(req, res) {
-  const span = tracer.startSpan('handleRequest');
-
-  try {
-    const user = await fetchUser(req.userId);
-    span.setAttribute('user.id', user.id);
-
-    const result = await processData(user);
-    res.json(result);
-  } finally {
-    span.end();
-  }
-}
-```
-
-## Resource Files
-
-### Tracing & APM
-- **[distributed-tracing.md](resources/distributed-tracing.md)** - Jaeger, Tempo, trace propagation, span design
-- **[opentelemetry.md](resources/opentelemetry.md)** - OTEL SDK, auto-instrumentation, collectors, exporters
-- **[apm-tools.md](resources/apm-tools.md)** - DataDog, New Relic, Dynatrace comparison
-
-### Logs & Correlation
-- **[logs-aggregation.md](resources/logs-aggregation.md)** - ELK Stack, Loki, structured logging
-- **[correlation-strategies.md](resources/correlation-strategies.md)** - Trace IDs, unified observability
-
-### Cost & Best Practices
-- **[observability-cost-optimization.md](resources/observability-cost-optimization.md)** - Sampling, retention, cost strategies
-
-## Best Practices
-
-✅ Use OpenTelemetry (vendor-neutral)
-✅ Implement structured logging
-✅ Correlate logs/metrics/traces (trace IDs)
-✅ Sample intelligently (head-based, tail-based)
-✅ Monitor observability costs
-✅ Create dashboards from traces
-✅ Use service mesh for automatic instrumentation
-
-## Integration Points
-
-- **sre**: Monitoring and alerting
-- **devsecops**: Security monitoring
-- **platform-engineering**: Service mesh observability
-- **backend-dev-guidelines**: Application instrumentation
-
----
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-🎯 SKILL ACTIVATED: observability-engineering
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-
-**Total Resources:** 6 focused guides on observability engineering
-**Focus:** Distributed tracing, OpenTelemetry, APM, cost optimization

package/.claude/skills/observability-engineering/resources/apm-tools.md

@@ -1,97 +0,0 @@
-# APM Tools
-
-Comparison and guide to Application Performance Monitoring tools: DataDog, New Relic, Dynatrace.
-
-## DataDog
-
-```typescript
-// DataDog APM
-import tracer from 'dd-trace';
-tracer.init({
-  service: 'my-app',
-  env: 'production',
-  version: '1.0.0',
-});
-
-// Auto-instruments Express, Prisma, Redis, etc.
-```
-
-**Pros:**
-- ✅ Easy setup (auto-instrumentation)
-- ✅ Unified logs/metrics/traces
-- ✅ Great dashboards
-- ✅ APM + infrastructure monitoring
-
-**Cons:**
-- ❌ Expensive at scale
-- ❌ Vendor lock-in
-
-## New Relic
-
-```javascript
-// newrelic.js
-exports.config = {
-  app_name: ['My App'],
-  license_key: process.env.NEW_RELIC_LICENSE_KEY,
-  distributed_tracing: {
-    enabled: true,
-  },
-};
-
-// Load before app
-require('newrelic');
-const app = require('./app');
-```
-
-**Pros:**
-- ✅ Powerful query language (NRQL)
-- ✅ Good for complex architectures
-- ✅ Real-time alerting
-
-**Cons:**
-- ❌ Steeper learning curve
-- ❌ Can be expensive
-
-## Dynatrace
-
-```
-Dynatrace OneAgent (auto-deploys)
-- No code changes required
-- Full-stack monitoring
-```
-
-**Pros:**
-- ✅ AI-powered root cause analysis
-- ✅ Zero-code instrumentation
-- ✅ Enterprise features
-
-**Cons:**
-- ❌ Most expensive
-- ❌ Overkill for small teams
-
-## Cost Comparison
-
-```
-Small team (5 services, 1M spans/month):
-- DataDog: ~$500/month
-- New Relic: ~$400/month
-- Dynatrace: ~$800/month
-
-Large team (50 services, 100M spans/month):
-- DataDog: ~$5,000/month
-- New Relic: ~$4,000/month
-- Dynatrace: ~$10,000/month
-```
-
-## Open Source Alternative
-
-```
-Jaeger + Prometheus + Grafana = $0
-(but requires self-hosting and maintenance)
-```
-
----
-
-**Related Resources:**
-- observability-cost-optimization.md - Cost management
-- opentelemetry.md - Vendor-neutral instrumentation

package/.claude/skills/observability-engineering/resources/correlation-strategies.md

@@ -1,87 +0,0 @@
-# Correlation Strategies
-
-Guide to correlating logs, metrics, and traces for unified observability.
-
-## Trace ID Propagation
-
-```typescript
-import { trace, context } from '@opentelemetry/api';
-import { logger } from './logger';
-
-app.use((req, res, next) => {
-  const span = trace.getActiveSpan();
-  const traceId = span?.spanContext().traceId;
-
-  // Attach trace ID to logger context
-  req.logger = logger.child({ traceId });
-
-  next();
-});
-
-app.get('/users/:id', async (req, res) => {
-  req.logger.info('Fetching user', { userId: req.params.id });
-  // Log includes traceId automatically
-
-  const user = await getUser(req.params.id);
-  res.json(user);
-});
-```
-
-## Unified Observability
-
-```
-Request arrives:
-1. Generate trace ID
-2. Create span (trace)
-3. Emit metrics (counter, histogram)
-4. Log with trace ID
-
-All three pillars linked by trace ID:
-- Logs: {"traceId": "abc123", "message": "User fetched"}
-- Metrics: user_requests_total{trace_id="abc123"}
-- Traces: Trace abc123 shows spans
-```
-
-## Correlation in Practice
-
-```typescript
-// 1. Start span (tracing)
-const span = tracer.startSpan('handleRequest');
-const traceId = span.spanContext().traceId;
-
-// 2. Log with trace ID (logs)
-logger.info('Processing request', { traceId, userId: req.userId });
-
-// 3. Increment metric (metrics)
-requestCounter.add(1, { traceId, endpoint: '/users' });
-
-// 4. All linked by traceId
-span.end();
-```
-
-## Querying Across Pillars
-
-```
-# Find all logs for a trace
-traceId:"abc123"
-
-# Find traces with errors
-status:error AND service:"user-service"
-
-# Find metrics for specific trace
-trace_id="abc123" AND metric="http_request_duration"
-```
-
-## Best Practices
-
-✅ Always propagate trace IDs
-✅ Include trace IDs in all logs
-✅ Use trace IDs in metric labels (when cardinality allows)
-✅ Link dashboards (click log → view trace)
-✅ Standardize field names (traceId, spanId)
-
----
-
-**Related Resources:**
-- distributed-tracing.md - Trace propagation
-- logs-aggregation.md - Structured logging with trace IDs

package/.claude/skills/observability-engineering/resources/distributed-tracing.md

@@ -1,98 +0,0 @@
-# Distributed Tracing
-
-Guide to implementing distributed tracing with Jaeger, Tempo, and other tools.
-
-## What is Distributed Tracing?
-
-Tracks requests as they flow through microservices:
-
-```
-User Request
-  ↓
-API Gateway (span 1) ──→ 50ms
-  ↓
-User Service (span 2) ──→ 20ms
-  ↓
-Database (span 3) ──────→ 80ms
-Total: 150ms
-
-Trace shows:
-- Total request time: 150ms
-- Database was bottleneck: 80ms (53%)
-```
-
-## Jaeger Setup
-
-```yaml
-# docker-compose.yml
-version: '3'
-services:
-  jaeger:
-    image: jaegertracing/all-in-one:latest
-    ports:
-      - "16686:16686"  # UI
-      - "14268:14268"  # HTTP collector
-      - "6831:6831/udp"  # Agent
-```
-
-## Instrumentation
-
-```typescript
-import { trace, context, SpanStatusCode } from '@opentelemetry/api';
-
-const tracer = trace.getTracer('user-service');
-
-async function getUser(userId: string) {
-  const span = tracer.startSpan('getUser');
-  span.setAttribute('user.id', userId);
-
-  try {
-    const user = await db.users.findUnique({ where: { id: userId } });
-    span.setStatus({ code: SpanStatusCode.OK });
-    return user;
-  } catch (error) {
-    span.setStatus({
-      code: SpanStatusCode.ERROR,
-      message: error.message
-    });
-    span.recordException(error);
-    throw error;
-  } finally {
-    span.end();
-  }
-}
-```
-
-## Trace Propagation
-
-```typescript
-// Service A creates trace
-const span = tracer.startSpan('callServiceB');
-const headers = {};
-
-// Inject trace context into headers
-propagation.inject(context.active(), headers);
-
-// Call Service B with trace context
-await fetch('http://service-b/api', { headers });
-
-span.end();
-
-// Service B continues the trace
-const extractedContext = propagation.extract(context.active(), req.headers);
-const span = tracer.startSpan('handleRequest', {}, extractedContext);
-```
-
-## Best Practices
-
-✅ Trace critical paths
-✅ Add meaningful attributes
-✅ Sample high-volume endpoints
-✅ Keep span names consistent
-✅ Record errors in spans
-
----
-
-**Related Resources:**
-- opentelemetry.md - OTEL implementation
-- correlation-strategies.md - Trace ID usage