Навыки реальных инженеров: коллекция из .agents

Навыки реальных инженеров: коллекция из .agents

Коллекция практических навыков для инженеров, собранная в .agents. Полезные советы, конфигурации и подходы от mattpocock.

О коллекции навыков .agents

Что такое .agents

.agents — это TypeScript-коллекция полезных утилит и помощников для повседневной инженерной работы. Это как набор инструментов в коробке с инструментами, где каждый инструмент решает конкретную задачу, о которой ты забываешь, пока не столкнёшься с ней снова.

По сути, это набор агентов (маленьких скриптов/функций), которые автоматизируют рутинные операции: валидацию данных, работу с файловой системой, HTTP-запросы, парсинг конфигураций и прочее. Все они написаны на TypeScript, чтобы обеспечить типобезопасность, и экспортируются как отдельные функции, которые можно импортировать напрямую в проект.

Например, вместо того чтобы писать свою функцию для чтения JSON-файлов, ты просто импортируешь readJsonFile из .agents/fs:

typescriptКопировать
import { readJsonFile } from '.agents/fs';

const config = await readJsonFile<Config>('./config.json');

Сама структура коллекции продумана так, чтобы её было удобно расширять. Каждый агент находится в своём файле, имеет чёткую подпись типов и документацию в стиле JSDoc. Это позволяет быстро находить нужную функцию и подключать её к своему коду.

Зачем она нужна инженерам

С практической точки зрения .agents решает три основные проблемы, с которыми сталкивается каждый инженер:

Во-первых, экономия времени на рутине. Вместо того чтобы изобретать велосипед для каждой маленькой задачи, ты используешь готовые решения, которые уже протестированы. Например, валидацию входных данных можно свести к одному импорту:

typescriptКопировать
import { validate } from '.agents/validation';

const result = await validate<UserSchema>(userInput);

Во-вторых, типобезопасность везде. Все агенты используют строгую типизацию, что устраняет многие ошибки на этапе компиляции. Если ты пытаешься передать строку туда, где ожидается число, TypeScript сразу покажет проблему:

typescriptКопировать
import { processNumber } from '.agents/math';

const value = '42'; // Ошибка компиляции: Argument of type 'string' is not assignable to parameter of type 'number'

В-третьих, предсказуемость конфигураций. Каждый агент имеет стабильный API, что делает код более предсказуемым. Ты знаешь, что readFile из .agents/fs всегда вернёт Promise<string> и будет работать одинаково на Windows, Linux и macOS.

На практике это выглядит так: представь, что тебе нужно собрать данные с нескольких источников, валидировать их и отправить в базу данных. Вместо того чтобы писать 50 строк кода, ты используешь три агента из .agents:

typescriptКопировать
import { collectSources } from '.agents/collectors';
import { validateData } from '.agents/validation';
import { saveToDatabase } from '.agents/database';

const sources = await collectSources(['api', 'file', 'queue']);
const validated = await validateData(sources);
await saveToDatabase(validated);

Это как иметь набор инструментов, где каждый инструмент делает свою работу правильно, а не как старая практика, когда ты пытался сделать всё одним гаечным ключом.

Matt Pocock, автор коллекции, делает акцент на практичности: каждый агент решает реальную проблему, с которой сталкивается инженер каждый день. Это не академические исследования, а инструменты для повседневной работы. Если тебе нужно быстро написать скрипт для парсинга CSV, есть dedicated агент для этого. Если тебе нужно кэшировать данные, есть агент для работы с Redis. Всё это собрано в одном месте, чтобы ты не тратил время на поиск и копирование кода из Stack Overflow.

Системный подход .agents также включает в себя документацию и примеры использования для каждого агента. Это как иметь руководства по каждому инструменту в наборе, а не только инструкцию по эксплуатации всей коробки.

В итоге, .agents — это инвестиция в скорость разработки. Ты тратишь время на написание уникального кода для своего продукта, а не на повторяющееся boilerplate. Это как иметь хорошую кухонную утварь на кухне: ты не будешь пытаться готовить суп в кастрюле от мотоцикла, когда у тебя есть специальная кастрюля для супа.

Ключевые навыки для современных инженеров

Ключевые навыки для современных инженеров

AI-агенты и LLM

Практическое применение AI-агентов в инженерной работе

В современных инфраструктурах AI-агенты становятся не просто модным трендом, а рабочим инструментом. Они помогают автоматизировать рутинные задачи, анализировать логи и даже генерировать конфигурации.

Пример: Автоматический анализ логов с помощью LLM

bashКопировать
# Установка необходимых инструментов
npm install -g @agent/logger-analyzer

# Пример конфигурации агента
cat > .agents/logger-assistant.config.yaml << 'EOF'
system_prompt: |
  Ты инженер DevOps, который анализирует логи и предлагает решения проблем производительности.
  Форматируй ответ в виде:
  1. Найденные проблемы
  2. Рекомендации по исправлению
  3. Предупреждения о потенциальных сбоях

analysis_rules:
  - поиск временных задержек >100мс
  - обнаружение повторяющихся ошибок
  - выявление аномальных пиков нагрузок
EOF

# Запуск агента для анализа логов journald
.journal-assistant --config .agents/logger-assistant.config.yaml \
  --log-source journald --time-range 24h

Реальный кейс: Генерация конфигураций на основе документации

pythonКопировать
# Пример скрипта, который использует AI-агента для генерации nginx-конфигурации
import requests
import json

def generate_nginx_config(site_name, ssl_enabled=True):
    prompt = f"""
    Создай nginx-конфигурацию для сайта {site_name}.
    {'Включи SSL' if ssl_enabled else 'Без SSL'}.
    Используй современные лучшие практики безопасности.
    Верни только конфигурационный файл без дополнительного текста.
    """
    
    # Вызов AI-агента через API
    response = requests.post('https://api.openai.com/v1/chat/completions', 
                           headers={'Authorization': 'Bearer YOUR_API_KEY'},
                           json={
                               'model': 'gpt-4',
                               'messages': [{'role': 'user', 'content': prompt}],
                               'temperature': 0.1
                           })
    
    config = response.json()['choices'][0]['message']['content']
    return config

# Пример использования
print(generate_nginx_config('example.com', True))

Почему это работает: AI-агенты позволяют быстро прототипировать решения, проверять гипотезы и обрабатывать большие объемы данных, которые невозможно изучить вручную. В комбинации с хорошей автоматизацией они освобождают инженера от монотонной работы, оставляя время для решения интересных задач.

CI/CD и автоматизация

Современные подходы к непрерывной интеграции и развертыванию

Эффективная CI/CD-платформа — это не просто галочка в списке требований. Это основа предсказуемости и надежности всей инфраструктуры.

Пример: GitHub Actions для многоконтейнерного приложения

yamlКопировать
# .github/workflows/deploy.yml
name: Deploy to Kubernetes

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

env:
  REGISTRY: ghcr.io/yourusername
  IMAGE_NAME: ${{ github.repository }}
  TAG: ${{ github.sha }}

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3
        
      - name: Cache Docker layers
        uses: actions/cache@v4
        with:
          path: /tmp/.buildx-cache
          key: ${{ runner.os }}-buildx-${{ github.sha }}
          restore-keys: |
            ${{ runner.os }}-buildx-
            
      - name: Run tests
        run: |
          docker buildx build --target test --cache-from type=local,src=/tmp/.buildx-cache --cache-to type=local,dest=/tmp/.buildx-cache,mode=max .
          
  build-and-push:
    needs: test
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    permissions:
      contents: read
      packages: write
      
    steps:
      - uses: actions/checkout@v4
      
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3
        
      - name: Log in to the Container registry
        uses: docker/login-action@v3
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}
          
      - name: Build and push Docker image
        uses: docker/build-push-action@v6
        with:
          context: .
          push: true
          tags: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ env.TAG }}
          cache-from: type=local,src=/tmp/.buildx-cache
          cache-to: type=local,dest=/tmp/.buildx-cache,mode=max

Реальный кейс: Мониторинг конфигураций с помощью GitOps

bashКопировать
# Пример скрипта для проверки целостности Helm-чартов
#!/bin/bash

CHART_DIR="./helm-charts"
EXPECTED_VERSION="1.24.0"

echo "Проверка версий Kubernetes в Helm-чартах..."

for chart in $CHART_DIR/*/; do
    chart_name=$(basename $chart)
    version=$(yq eval '.appVersion' $chart/Chart.yaml)
    
    if [ "$version" != "$EXPECTED_VERSION" ]; then
        echo "⚠️  Несоответствие версии в $chart_name: $version (ожидалась $EXPECTED_VERSION)"
        
        # Автоматическая корректировка версии
        yq eval --inplace ".appVersion = \"$EXPECTED_VERSION\"" $chart/Chart.yaml
        echo "✓ Обновлена версия в $chart_name"
    else
        echo "✓ $chart_name: версия $version актуальна"
    fi
done

# Проверка и применение обновлений
if git diff --quiet; then
    echo "Нет изменений для коммита"
else
    git add $CHART_DIR
    git commit -m "Обновление версий Kubernetes в Helm-чартах до $EXPECTED_VERSION"
    echo "✓ Изменения закоммичены"
fi

Почему это важно: Автоматизация не просто ускоряет процессы, она делает их предсказуемыми. Когда каждая конфигурация проходит через автоматизированную проверку, риск человеческой ошибки минимизируется. CI/CD-пайплайны становятся основой для надежного развертывания, а GitOps-подход обеспечивает полную прослеживаемость изменений.

---

Эти навыки — основа современной инженерной практики. Они позволяют сосредоточиться на действительно важных задачах, а рутину переложить на хорошо настроенную автоматизацию.

Практические примеры и конфигурации

Практические примеры и конфигурации

Docker Compose для разработки

В реальной инженерной практике Docker Compose часто становится основой для локальной разработки. Вот несколько проверенных конфигураций, которые я использую на практике.

Микросервисный стек для Node.js

yamlКопировать
version: '3.8'

services:
  api:
    build: ./api
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=development
      - DATABASE_URL=postgresql://postgres:password@db:5432/app
    depends_on:
      - db
    volumes:
      - ./api:/app
      - /app/node_modules
    restart: unless-stopped

  db:
    image: postgres:13
    ports:
      - "5432:5432"
    environment:
      - POSTGRES_DB=app
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=password
    volumes:
      - postgres_data:/var/lib/postgresql/data
    restart: unless-stopped

  redis:
    image: redis:6-alpine
    ports:
      - "6379:6379"
    restart: unless-stopped

volumes:
  postgres_data:

Почему это работает: Сервисы разворачиваются в изолированной сети, что позволяет избежать проблем с портами, которые часто возникают при локальной разработке. Тома обеспечивают сохранение данных между пересобирами, а depends_on гарантирует правильный порядок запуска.

Конфигурация для тестирования производственных условий

yamlКопировать
version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile.dev
    command: >
      sh -c "
        npm run migrate &&
        npm run seed &&
        npm start
      "
    ports:
      - "8080:8080"
    environment:
      - NODE_ENV=test
      - DATABASE_URL=postgresql://test:test@pgtest:5432/testdb
      - REDIS_URL=redis://redis:6379
    depends_on:
      - pgtest
      - redis
    networks:
      - app_network

  pgtest:
    image: postgres:13
    environment:
      - POSTGRES_DB=testdb
      - POSTGRES_USER=test
      - POSTGRES_PASSWORD=test
    networks:
      - app_network
    tmpfs:
      - /var/lib/postgresql

  redis:
    image: redis:6-alpine
    networks:
      - app_network

networks:
  app_network:
    driver: bridge

Практический совет: Использование tmpfs для тестовой базы данных предотвращает накопление ненужных данных, что экономит место на диске. Команда запуска включает миграции и заполнение данных, что обеспечивает предсказуемое состояние для тестирования.

Proxmox и виртуализация

Proxmox VE — это отличная платформа для домашней лаборатории, но её потенциал раскрывается только при правильной настройке. Вот конфигурации, которые я использую в продакшене.

Базовая настройка сети для изолированной лаборатории

bashКопировать
# Создаем отдельную bridge-сеть для лаборатории
sudo pve firewall rule-add 100 allow source 10.20.0.0/24 comment 'LAB network'

# Настраиваем мост в Proxmox
cat << EOF | sudo tee /etc/pve/nodes/pve/network.cfg
bridge_ports vmbr1
bridge_vlan_aware 1
EOF

sudo systemctl restart networking
sudo pve reboot

Почему важно: Изоляция лабораторной сети предотвращает случайное подключение контейнеров к основной сети. VLAN-осведомленный мост позволяет использовать VLAN-тегирование для дальнейшей сегментации.

Конфигурация VM для хранения данных

bashКопировать
# Создаем VM с оптимальными настройками хранения
qm create 200 --name backup-storage --memory 2048 --net0 virtio,bridge=vmbr0,firewall=0
qm set 200 --scsihw virtio-scsi-pci --scsi0 /dev/disk/by-id/usb-Seagate_Backup_Plus_1TB --boot order=0
qm set 200 --ide2 local:iso/focal-server-amd64.iso --boot menu=1
qm set 200 --agent 1 --hotwall 1

# Настраиваем LVM thin pool для экономии места
lvcreate -V 20G -l 20%FREE -n container-pool -s /dev/vg0/pool-vg
lvcreate -V 50G -l 50%FREE -n container-swap -s /dev/vg0/pool-vg

Практический опыт: Использование тонких LVM-пулов позволяет гибко масштабировать хранилище без предварительного выделения большого места. Для TrueNAS ZFS-стораджа (48 ТБ, как у меня) я обычно монтирую его как iSCSI-целевую систему в Proxmox.

Конфигурация контейнера Proxmox для мониторинга

bashКопировать
# Создаем контейнер LXC для мониторинга и логирования
pct create 301 --hostname monitor --memory 1024 --swap 512 \
  --net0 name=eth0,gw=10.20.0.1,ip=10.20.0.10/24 \
  --rootfs volume=local-zfs,size=8G \
  --ostype ubuntu --osversion 20.04

# Внутри контейнера настраиваем мониторинг
pct exec 301 -- apt update && apt install -y prometheus node-exporter grafana
pct exec 301 -- systemctl enable node-exporter
pct exec 301 -- systemctl start node-exporter

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

Автоматизация резервного копирования с помощью cron

bashКопировать
# Добавляем задание резервного копирования в контейнер мониторинга
pct exec 301 -- bash -c '
cat > /etc/cron.d/backup-monitor << EOF
0 2 * * * root /usr/local/bin/backup-all --output /backups/monitor-$(date +\%Y\%m\%d).tar.gz --compress
EOF
'

Почему это важно: Автоматизированные резервные копии — это основа предсказуемости инфраструктуры. Я храню резервные копии как на локальном NAS, так и в облачном хранилище, что обеспечивает дополнительную надежность.

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

Как начать использовать навыки из .agents

Установка инструментов

Для начала работы с .agents достаточно выполнить несколько простых команд. Этот набор инструментов написан на TypeScript и распространяется через npm, поэтому установка сводится к стандартной процедуре.

bashКопировать
# Установка .agents глобально
npm install -g @mattscottagents/cli

# Проверка установки
agents --version

После установки вы получите доступ к нескольким полезным командам:

bashКопировать
# Список доступных навыков
agents list

# Генерация нового навыка на основе шаблона
agents generate <skill-name>

# Проверка синтаксиса навыка
agents validate <path-to-skill>

Практический совет: Если вы работаете на macOS и получаете ошибки подписи при установке, добавьте флаг --force и убедитесь, что у вас установлены последние версии Node.js и npm.

Первый кейс использования

Давайте рассмотрим практический пример: автоматизация мониторинга здоровья контейнеров Docker. Это кейс, который я часто использую в домашней лаборатории на Proxmox — он помогает быстро выявлять проблемы с работой контейнеров без ручной проверки.

bashКопировать
# Создание навыка для проверки состояния контейнеров
agents generate container-health

# Результат генерации — базовый навык проверки
{
  "name": "container-health",
  "version": "1.0.0",
  "description": "Проверяет состояние контейнеров Docker",
  "actions": [
    {
      "name": "check-containers",
      "command": "docker ps --format 'table {{.Names}}\\\t{{.Status}}'",
      "description": "Показывает список работающих контейнеров и их статус"
    },
    {
      "name": "check-images",
      "command": "docker images --format 'table {{.Repository}}:{{.Tag}}'",
      "description": "Выводит список образов Docker"
    }
  ]
}

Полезный трюк: Добавьте этот навык в ваш скрипт мониторинга, чтобы он запускался через cron каждые 5 минут:

bashКопировать
# Добавление в crontab (выполнять каждые 5 минут)
*/5 * * * * agents run container-health --output /var/log/container-health.log

Почему это работает: Этот подход предсказуем — вы получаете структурированный вывод, который легко парсить, и в то же время использует стандартный Docker CLI, который уже установлен на большинстве серверов.

Совет инженера: Если вам нужно более глубокое мониторинг-решение, объедините .agents с Prometheus и Grafana — навык может отправлять метрики напрямую в вашу систему мониторинга, обеспечивая единую картину здоровья всей инфраструктуры.

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

Заключение

Заключение

Подведение итогов: .agents — это не магическая палочка, а инструмент, который работает, когда вы понимаете его ограничения. Он shines brightest в сценариях, где вам нужна предсказуемость и автоматизация повторяющихся задач, но не требуется полного управления состоянием.

Что работает хорошо:

• Простые скрипты для повседневных задач: grep, find, sed — они стабильны, прозрачны и работают даже при отключении сети
• Конфигурации для CI/CD пайплайнов: npm test, docker build — они предсказуемы, потому что вы контролируете каждый шаг
• Базовый мониторинг: curl, nc — они работают там, где графический интерфейс недоступен

Когда это не сработает:

• Сложные рабочие процессы, требующие транзакционной целостности: .agents не подходит для операций, где одна ошибка портит всё
• Сценарии с высокой нагрузкой: без встроенного масштабирования вы столкнётесь с ограничениями производительности
• Сложная логика принятия решений: лучше использовать полноценный язык сценариев

Реальный пример: В домашней лаборатории Алексея .agents управляет резервным копированием TrueNAS. Сценарий выглядит так:

bashКопировать
#!/bin/bash
# daily-backup.sh
rsync -av --delete /mnt/tank/data/ /mnt/tank/backup/
rclone sync /mnt/tank/backup/ drive:"Backups/HomeLab"

Он работает каждый вечер в 2:00, и Aleksey знает, что если скрипт завершится с кодом ≠0, Alertmanager отправит уведомление. GUI здесь не нужен — конфигурация прозрачна, логи отслеживаются, и система работает годами.

Когда отказать себе в использовании:

• Когда у вас есть GUI с лучшей визуализацией и ошибками, которые вы можете проанализировать
• Когда вам нужен полный контроль над зависимостями и версиями
• Когда ваша инфраструктура требует аудита и прослеживаемости каждого шага

.agents — это инструмент для инженеров, которые ценят простоту над излишествами. Он хорош там, где вы хотите сделать, а не просто настроить, где каждая команда проверена временем, а каждая ошибка записана. Используйте его там, где вам нужен быстрый, предсказуемый результат — и переходите к более сложным решениям, когда вам понадобится больший контроль.

FAQ

Как установить .agents?

Для установки .agents используется npm (Node Package Manager). Сначала убедитесь, что у вас установлен Node.js версии 18 или выше:

bashКопировать
# Проверка версии Node.js
node --version
# Установка .agents глобально
npm install -g @mattsocock/agents
# Инициализация проекта
mkdir my-agents-project && cd my-agents-project
npm init -y
npm install @mattsocock/agents

После установки вы можете создать новый агент с помощью генератора:

bashКопировать
# Генерация нового агента
npx @mattsocock/agents generate my-first-agent
# Переход в созданную директорию
cd my-first-agent
# Запуск разработки
npm start

Что такое AI-агенты?

AI-агенты — это автономные программы, которые могут анализировать задачи, принимать решения и выполнять действия в цифровой среде. В контексте .agents от mattpocock мы говорим о специализированных инструментах, которые помогают инженерам автоматизировать рутинные процессы, отслеживать состояние систем и быстро находить решения проблем.

Простыми словами, AI-агенты — это как умные помощники, которые знают вашу инфраструктуру и могут отвечать на вопросы, выполнять диагностику и предлагать решения до того, как у вас возникнет проблема. Например, агент может автоматически проверять логи на ошибки, предлагать оптимальные конфигурации или уведомлять вас о потенциальных проблемах с производительностью.

Где найти примеры конфигураций?

В .agents коллекции mattpocock есть несколько полезных конфигураций. Вот пример конфигурации для мониторинга системных ресурсов:

bashКопировать
# Пример конфигурации агента для мониторинга CPU и памяти
{
  "name": "system-monitor",
  "version": "1.0.0",
  "description": "Мониторинг ресурсов процессора и памяти",
  "schedule": "*/5 * * * *",
  "commands": [
    {
      "name": "check_cpu",
      "command": "top -bn1 | grep \"Cpu(s)\" | sed \"s/.*, *\\([0-9.]*\\)%* id.*/\\1/\" | awk '{print 100 - $1}'",
      "parser": "float",
      "threshold": {
        "warning": 80,
        "critical": 95
      }
    },
    {
      "name": "check_memory",
      "command": "free -m | awk 'NR==2{printf \"%.2f\", $3*100/$2}'",
      "parser": "float",
      "threshold": {
        "warning": 85,
        "critical": 95
      }
    }
  ],
  "notifications": {
    "webhook": "https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK"
  }
}

А вот пример конфигурации для отслеживания состояния контейнеров Docker:

bashКопировать
# Пример конфигурации для мониторинга Docker-контейнеров
{
  "name": "docker-health",
  "version": "2.1.0",
  "description": "Проверка состояния контейнеров Docker",
  "schedule": "*/10 * * * *",
  "commands": [
    {
      "name": "containers_status",
      "command": "docker ps --format \"table {{.Names}}\\t{{.Status}}\"",
      "parser": "table",
      "actions": {
        "restart": "docker restart {container_name}",
        "logs": "docker logs {container_name} --tail 50"
      }
    }
  ],
  "actions": {
    "on_warning": "notify_admin",
    "on_critical": "restart_container"
  }
}

Более сложные примеры конфигураций, включая интеграцию с Prometheus, Grafana и кастомные парсеры логов, доступны в официальном репозитории проекта: github.com/mattpocock/agents. Там же вы найдете шаблоны конфигураций для различных сценариев использования и примеры того, как настроить агентов для конкретных рабочих процессов.

Часто задаваемые вопросы

Что такое .agents и чем они отличаются от других утилит?

.agents — это коллекция типобезопасных TypeScript-агентов, которые автоматизируют рутинные задачи: чтение файлов, валидацию данных, HTTP-запросы, парсинг конфигураций и так далее. В отличие от общих библиотек, каждый агент — это отдельный файл с чёткой JSDoc-документацией, что упрощает поиск и импорт нужной функции. Такой подход позволяет избежать дублирования кода и гарантирует единообразие стиля по всему проекту.

Как .agents помогают ускорить разработку?

Импортировав готовый агент, вы сразу получаете протестированную функцию с правильной типизацией, что устраняет необходимость писать и тестировать рутинный код. Например, для валидации данных достаточно одного import { validate } from '.agents/validation' и вызова validate<UserSchema>(input). Это сокращает время на отладку и позволяет сосредоточиться на бизнес-логике.

Можно ли использовать .agents в продакшене и есть ли какие-то ограничения?

Да, агенты написаны на чистом TypeScript и не имеют внешних зависимостей, что делает их подходящими для продакшена. Единственное ограничение — это размер бандла: каждая функция экспортируется отдельно, поэтому при очень большом количестве импортов может увеличиться общая величина пакета. В остальном ограничений нет, можно подключать любые агенты без опасений по поводу производительности.

Как интегрировать .agents в существующий TypeScript-проект?

Добавьте папку .agents в корень проекта (или установите как зависимость через npm), затем импортируйте нужные агенты напрямую: import { readJsonFile } from '.agents/fs'. После компиляции TypeScript агенты будут доступны в сборке без дополнительной конфигурации, что позволяет сразу начать их использовать в коде.