DevToolBox

Advanced developer tools for Git integration, workflow automation, sandboxed execution, issue triage, and CI/CD monitoring

v4.1.0

Prerequisites

What you need to get started with DevToolBox features.

Eldric Controller Required

The Controller daemon must be running. This is the central hub for all DevToolBox features.

eldric-controller --port 8880

Git Forge Account For Git Features

GitHub, GitLab, or Gitea account with an API token for repository integration, PR automation, and issue triage.

Docker For Sandboxes

Docker must be installed and running for sandboxed code execution with resource limits and network isolation.

Inference Backend For AI Features

An LLM backend (Ollama, vLLM, or cloud API) is required for issue triage, code review, and AI-powered skills.

Additional Recommendations

  • Agent Worker (eldric-agentd) recommended for multi-agent skills
  • CI/CD webhook access for pipeline monitoring
  • Data Worker (eldric-datad) for persistent storage
  • License: Free tier includes skills, automations, triage, and integration builder; Professional+ for CI/CD monitoring

Architecture

DevToolBox Integration
DEVTOOLBOX ECOSYSTEM Git Forges GitHub GitLab Gitea Skills Code Review Test Generation Doc Generation Automations Git Triggers Webhooks Schedules Sandboxes Docker Containers Resource Limits Network Isolation Agent Orchestration Layer (Swarm + Parallel Execution) Data Worker Storage Issue Triage CI/CD Monitor

Quick Start Examples

Get started with DevToolBox in minutes. Here are practical examples for common workflows.

Example 1: Automated PR Review Pipeline

Set up automatic code review for every pull request:

# 1. Add your GitHub forge
/git add github https://github.com --token ghp_your_token --alias gh

# 2. Create a code-review skill
/skill create pr-review

# 3. Create automation triggered on PR open
curl -X POST http://dataworker:8892/api/v1/automations \
  -H "Content-Type: application/json" \
  -d '{
    "name": "auto-review-pr",
    "trigger": {"type": "git_pr_opened", "forge": "gh", "repo": "myorg/myrepo"},
    "actions": [
      {"skill": "code-review", "inputs": {"repo": "{{trigger.repo}}", "pr": "{{trigger.pr_number}}"}},
      {"type": "comment", "target": "{{trigger.pr_url}}", "body": "## AI Review\n{{skill.output.report}}"}
    ]
  }'

# 4. Every new PR now gets automatic review!

Example 2: Sandboxed Code Execution

Safely run untrusted code in isolated containers:

# Create a Python sandbox with resource limits
curl -X POST http://dataworker:8892/api/v1/sandboxes \
  -H "Content-Type: application/json" \
  -d '{
    "name": "python-dev",
    "image": "python:3.12-slim",
    "limits": {"cpu": "2", "memory": "2g", "timeout_seconds": 300},
    "network": {"mode": "restricted", "allowed_hosts": ["pypi.org"]}
  }'

# Execute code in the sandbox
curl -X POST http://dataworker:8892/api/v1/sandboxes/sbx-abc123/exec \
  -H "Content-Type: application/json" \
  -d '{
    "command": "pip install numpy && python -c \"import numpy; print(numpy.random.rand(3,3))\""
  }'

# Response:
{
  "exit_code": 0,
  "output": "[[0.123 0.456 0.789]\n [0.234 0.567 0.890]\n [0.345 0.678 0.901]]",
  "duration_ms": 2340
}

Example 3: Issue Triage with AI

Automatically analyze and label issues:

# Analyze a GitHub issue
curl -X POST http://dataworker:8892/api/v1/triage/analyze \
  -H "Content-Type: application/json" \
  -d '{"issue": "github:myorg/myrepo#42"}'

# Response:
{
  "labels": ["bug", "security", "high-priority"],
  "priority": "P1",
  "category": "security-vulnerability",
  "suggested_assignees": ["alice", "bob"],
  "related_issues": [38, 41],
  "duplicate_of": null,
  "fix_suggestion": {
    "description": "SQL injection in user input - sanitize query parameters",
    "files": ["src/api/users.py:145", "src/api/users.py:167"],
    "confidence": 0.92,
    "code_snippet": "# Replace:\nquery = f\"SELECT * FROM users WHERE id = {user_id}\"\n# With:\nquery = \"SELECT * FROM users WHERE id = %s\"\ncursor.execute(query, (user_id,))"
  }
}

Example 4: CI/CD Failure Analysis

Diagnose and fix build failures automatically:

# Monitor a repository's CI/CD
/cicd add github:myorg/myrepo

# When a build fails, analyze it
curl -X POST http://dataworker:8892/api/v1/cicd/analyze \
  -H "Content-Type: application/json" \
  -d '{"repo": "github:myorg/myrepo", "run_id": "12345"}'

# Response:
{
  "status": "failed",
  "failed_job": "test",
  "failed_step": "Run pytest",
  "error_type": "test_failure",
  "error_summary": "2 tests failed in tests/test_api.py",
  "root_cause": "Missing mock for external API call in test_user_creation",
  "fix_suggestion": {
    "description": "Add mock for external service",
    "file": "tests/test_api.py",
    "line": 45,
    "patch": "@mock.patch('app.services.external_api.create_user')\ndef test_user_creation(mock_create):\n    mock_create.return_value = {'id': 1, 'status': 'created'}\n    ..."
  },
  "similar_failures": [
    {"run_id": "12340", "date": "2024-02-01", "same_root_cause": true}
  ]
}

Example 5: Custom Multi-Agent Skill

Create a skill that combines multiple agents:

# Create a "security-audit" skill
curl -X POST http://dataworker:8892/api/v1/skills \
  -H "Content-Type: application/json" \
  -d '{
    "id": "security-audit",
    "name": "Security Audit",
    "description": "Comprehensive security review of codebase",
    "version": "1.0.0",
    "inputs": [
      {"name": "repo", "type": "git_repo", "required": true},
      {"name": "severity_threshold", "type": "string", "default": "medium"}
    ],
    "steps": [
      {
        "id": "scan",
        "agent": "explorer",
        "action": "find_files",
        "params": {"patterns": ["*.py", "*.js", "*.ts"]},
        "output": "source_files"
      },
      {
        "id": "analyze",
        "agent": "coder",
        "action": "security_scan",
        "input": "source_files",
        "params": {"checks": ["sql_injection", "xss", "secrets", "dependencies"]},
        "output": "vulnerabilities"
      },
      {
        "id": "prioritize",
        "agent": "validator",
        "action": "rank_issues",
        "input": "vulnerabilities",
        "params": {"threshold": "{{severity_threshold}}"},
        "output": "prioritized_issues"
      },
      {
        "id": "report",
        "agent": "planner",
        "action": "generate_report",
        "input": "prioritized_issues",
        "output": "security_report"
      }
    ],
    "outputs": ["security_report", "prioritized_issues"]
  }'

# Run the skill
/skill run security-audit --repo github:myorg/myrepo --severity_threshold high

Git Forge Integration

Unified interface for GitHub, GitLab, and Gitea. Clone repositories, manage issues and PRs, and trigger automations from any forge.

GitHub

Full GitHub API integration including repos, issues, PRs, Actions, and webhooks.

  • OAuth and token authentication
  • GitHub Actions integration
  • PR review automation

GitLab

GitLab CE/EE support with CI/CD pipelines and merge request automation.

  • Self-hosted and cloud
  • CI/CD pipeline triggers
  • Merge request automation

Gitea

Self-hosted Git with Gitea Actions support and lightweight deployment.

  • Self-hosted control
  • Gitea Actions support
  • Lightweight footprint

CLI Commands

# Add a Git forge
/git add github https://github.com --token ghp_xxxx

# Add GitLab forge with alias
/git add gitlab https://gitlab.com --token glpat-xxxx --alias gl

# Add self-hosted Gitea
/git add gitea https://git.example.com --token your-token

# List configured forges
/git list

# Clone repository to Data Worker
/git clone github:org/repo

# Sync repository (pull latest)
/git sync github:org/repo

# List issues
/git issues github:org/repo

# Create pull request
/git pr create github:org/repo --title "Fix bug" --branch feature-branch

Configuration

Git forges are configured in ~/.config/eldric/git_forges.json:

{
  "forges": [
    {
      "id": "github-main",
      "type": "github",
      "url": "https://github.com",
      "alias": "gh",
      "auth": {
        "type": "token",
        "token": "ghp_xxxxxxxxxxxx"
      }
    },
    {
      "id": "gitlab-work",
      "type": "gitlab",
      "url": "https://gitlab.company.com",
      "alias": "gl",
      "auth": {
        "type": "token",
        "token": "glpat-xxxxxxxxxxxx"
      }
    }
  ]
}

Skills System

Reusable, multi-step agent workflows. Skills combine multiple agents into coordinated pipelines for complex tasks.

Built-in Code Review

Automated code review with Explorer, Coder, and Validator agents.

  • Security vulnerability detection
  • Code style analysis
  • Performance suggestions

Built-in Test Generation

Generate unit tests for your codebase automatically.

  • Framework detection
  • Edge case coverage
  • Mocking strategies

Built-in Documentation

Generate documentation from code analysis.

  • API documentation
  • README generation
  • Inline comments

Custom Your Skills

Create custom skills tailored to your workflow.

  • JSON definition format
  • Multi-agent pipelines
  • Input/output parameters

Skill Definition Format

{
  "id": "code-review",
  "name": "Code Review",
  "description": "Review code changes for issues and improvements",
  "version": "1.0.0",
  "inputs": [
    {"name": "repo", "type": "git_repo", "required": true},
    {"name": "branch", "type": "string", "default": "main"},
    {"name": "focus", "type": "string", "default": "security,performance"}
  ],
  "steps": [
    {"agent": "explorer", "action": "list_changes", "output": "changed_files"},
    {"agent": "coder", "action": "analyze_code", "input": "changed_files", "output": "analysis"},
    {"agent": "validator", "action": "check_issues", "input": "analysis", "output": "report"}
  ],
  "outputs": ["report", "suggestions"]
}

CLI Commands

# List available skills
/skill list

# Run a skill
/skill run code-review --repo github:org/repo --branch main

# Create custom skill
/skill create my-skill

# Edit skill definition
/skill edit my-skill

# Delete skill
/skill delete my-skill

# Show skill details
/skill show code-review

Automations

Event-driven workflows triggered by Git events, schedules, webhooks, or file changes.

Trigger Types

Git Events

  • Push to branch
  • Pull request opened/merged
  • Issue created
  • Tag created

Other Triggers

  • Cron schedule
  • Webhook POST
  • File system changes
  • Manual invocation

Automation Definition

{
  "id": "auto-review-pr",
  "name": "Auto Review Pull Requests",
  "enabled": true,
  "trigger": {
    "type": "git_pr_opened",
    "forge": "github",
    "repo": "org/repo"
  },
  "conditions": [
    {"type": "file_pattern", "pattern": "src/**/*.ts"},
    {"type": "label_absent", "label": "skip-review"}
  ],
  "actions": [
    {
      "skill": "code-review",
      "inputs": {
        "repo": "{{trigger.repo}}",
        "branch": "{{trigger.branch}}"
      }
    },
    {
      "type": "comment",
      "target": "{{trigger.pr_url}}",
      "body": "{{skill.output.report}}"
    }
  ]
}

CLI Commands

# List automations
/auto list

# Create automation
/auto create pr-review

# Enable/disable automation
/auto enable pr-review
/auto disable pr-review

# Trigger automation manually
/auto trigger pr-review --pr github:org/repo#123

# View automation logs
/auto logs pr-review

# Delete automation
/auto delete pr-review

Sandboxed Execution

Isolated Docker containers for safe code execution with resource limits and network isolation.

Docker Containers

Each sandbox runs in an isolated Docker container with configurable base images.

Resource Limits

Configure CPU, memory, and disk limits for each sandbox.

Network Isolation

Control network access - allow, deny, or restrict to specific hosts.

Sandbox Configuration

{
  "name": "python-sandbox",
  "image": "python:3.12-slim",
  "limits": {
    "cpu": "2",
    "memory": "2g",
    "disk": "10g",
    "timeout_seconds": 300
  },
  "network": {
    "mode": "restricted",
    "allowed_hosts": ["pypi.org", "github.com"]
  },
  "mounts": [
    {"source": "/data/workspace", "target": "/workspace", "readonly": false}
  ],
  "env": {
    "PYTHONDONTWRITEBYTECODE": "1"
  }
}

CLI Commands

# Create sandbox
/sandbox create python-dev --image python:3.12 --cpu 2 --memory 2g

# List active sandboxes
/sandbox list

# Execute command in sandbox
/sandbox exec python-dev "pip install numpy && python script.py"

# Get sandbox status
/sandbox status python-dev

# Destroy sandbox
/sandbox destroy python-dev

# Destroy all sandboxes
/sandbox destroy-all

Issue Triage

AI-powered issue analysis for automatic labeling, priority assignment, and fix suggestions.

Features

  • Automatic label suggestions
  • Priority classification (P0-P4)
  • Suggested assignees based on expertise
  • Related issue detection
  • Fix suggestions with code references
  • Duplicate detection

Triage Output

{
  "labels": ["bug", "security", "urgent"],
  "priority": "P1",
  "suggested_assignees": ["alice", "bob"],
  "related_issues": [123, 456],
  "fix_suggestion": {
    "description": "Sanitize user input",
    "files": ["src/api/handler.ts:45"],
    "confidence": 0.87
  }
}

CLI Commands

# Analyze a specific issue
/triage analyze github:org/repo#123

# Analyze all open issues
/triage analyze-all github:org/repo --limit 50

# Auto-label issues
/triage auto-label github:org/repo#123

# Find related issues
/triage related github:org/repo#123

# Suggest fix
/triage suggest-fix github:org/repo#123

CI/CD Monitor

Monitor build pipelines, analyze failures, and get AI-powered fix suggestions.

CI System Status Monitoring Failure Analysis Auto-fix
GitHub Actions Full Full Yes
GitLab CI Full Full Yes
Gitea Actions Full Full Yes
Jenkins Full Basic Limited

CLI Commands

# Get pipeline status
/cicd status github:org/repo

# List recent builds
/cicd builds github:org/repo --limit 10

# Analyze failed build
/cicd analyze github:org/repo --run 12345

# Get fix suggestions for failure
/cicd fix github:org/repo --run 12345

# Re-run failed build
/cicd rerun github:org/repo --run 12345

# Monitor builds in real-time
/cicd watch github:org/repo

IDE Extensions

Use DevToolBox directly from your IDE with extensions for VS Code and JetBrains.

VS Code Extension

Full DevToolBox integration for Visual Studio Code.

  • Sidebar panel: Forges, Skills, Automations, Sandboxes, CI/CD
  • Prompt Playground webview with streaming
  • Agent Debugger with step-through visualization
  • Run selected code in sandboxed containers
  • "Fix with Eldric" quick-fix on diagnostics
  • CI/CD pipeline status in status bar

Installation

# From source
cd extensions/vscode
npm install && npm run compile

# Package as VSIX
npx vsce package

# Install VSIX
code --install-extension eldric-devtoolbox-1.0.0.vsix

Configuration

// settings.json
{
  "eldric.controllerUrl": "http://localhost:8880",
  "eldric.apiKey": "your-api-key",
  "eldric.defaultModel": "llama3.2:3b"
}

JetBrains Plugin

Full DevToolBox integration for IntelliJ IDEA, PyCharm, WebStorm, and all JetBrains IDEs.

  • Tool window with 4 tabs: Playground, Debugger, Sandbox, CI/CD
  • Editor context actions: Run in Sandbox, Fix with Eldric
  • Issue analysis from editor context menu
  • CI/CD status bar widget
  • Pipeline failure notifications
  • Persistent settings per project

Installation

# Build from source (requires JDK 17+)
cd extensions/jetbrains
./gradlew build

# Install plugin
# Settings → Plugins → Install from disk
# Select build/distributions/*.zip

Configuration

# Settings → Tools → Eldric DevToolBox
Controller URL: http://localhost:8880
API Key: your-api-key
Default Model: llama3.2:3b

Integration Builder

Visual drag-and-drop workflow editor for building automation pipelines. Design complex integrations by connecting nodes on a canvas, then deploy as Skills and Automations.

Dashboard URL: http://controller:8880/dashboard/integrations

Access the visual workflow editor from the Controller dashboard. No code required.

Node Types

Node Description Configuration
Trigger Entry point that starts the workflow git_push, git_pr, schedule, webhook, file_change, manual
Action Execute a task run_skill, call_api, send_notification, execute_command
Condition If/else branching Boolean expression with template variables
Transform Map data between nodes Field mappings, jq-like expressions
Loop Iterate over collections Collection expression, item variable, max iterations
Parallel Fan-out execution Max concurrency, wait strategy, timeout
Human Approval / input gate Prompt, approvers, timeout, notification channel

Starter Templates

Template PR Review Pipeline

GitPR Trigger → Run CodeReview Skill → Post Comment → Notify Slack

Automatically review every pull request with AI-powered code analysis and post results as PR comments.

Template Deploy on Push

GitPush Trigger → Run Tests → Condition (pass?) → Deploy → Notify

Continuous deployment pipeline that tests and deploys when code is pushed to main.

Template Issue Triage

GitIssue Trigger → Analyze Issue → Auto-Label → Assign → Notify

Automatically analyze new issues, assign labels and priority, and route to the right developer.

Template Scheduled Report

Schedule Trigger → Query Metrics → Generate Report → Email

Generate periodic reports from cluster metrics and deliver via email on a cron schedule.

API Endpoints

Endpoint Method Description
/api/v1/devtoolbox/integrations GET List saved integrations
/api/v1/devtoolbox/integrations POST Create integration from workflow graph
/api/v1/devtoolbox/integrations/{id} GET/PUT/DELETE Get, update, or delete integration
/api/v1/devtoolbox/integrations/{id}/validate POST Validate workflow graph
/api/v1/devtoolbox/integrations/{id}/execute POST Execute integration
/api/v1/devtoolbox/integrations/{id}/logs GET Get execution logs
/api/v1/devtoolbox/integrations/templates GET Get starter templates

Example: Create Integration via API

# Create a PR review integration
curl -X POST http://controller:8880/api/v1/devtoolbox/integrations \
  -H "Content-Type: application/json" \
  -d '{
    "name": "PR Review Pipeline",
    "description": "Auto-review pull requests",
    "nodes": [
      {"id": "n1", "type": "trigger", "name": "PR Opened",
       "trigger": {"subtype": "git_pr", "repo": "org/repo"}},
      {"id": "n2", "type": "action", "name": "Code Review",
       "action": {"subtype": "run_skill", "skill_id": "code-review"}},
      {"id": "n3", "type": "action", "name": "Post Comment",
       "action": {"subtype": "call_api"}},
      {"id": "n4", "type": "action", "name": "Notify Slack",
       "action": {"subtype": "send_notification", "notification_channel": "slack"}}
    ],
    "edges": [
      {"source_node_id": "n1", "target_node_id": "n2"},
      {"source_node_id": "n2", "target_node_id": "n3"},
      {"source_node_id": "n3", "target_node_id": "n4"}
    ]
  }'

# Response:
{
  "id": "intg-a1b2c3d4",
  "status": "draft",
  "nodes": 4,
  "edges": 3
}

License Tiers

DevToolBox features are available across all license tiers with increasing limits.

Feature Free Professional Enterprise
Git Forges 3 10 Unlimited
Skills 20 100 Unlimited
Automations 10 50 Unlimited
Sandboxes (concurrent) 3 10 Unlimited
Issue Triage Basic Full Full
CI/CD Monitor - Yes Yes
Integration Builder 3 workflows 20 workflows Unlimited
IDE Extensions Yes Yes Yes

API Reference

DevToolBox features are accessible via the Data Worker REST API.

Endpoint Method Description
/api/v1/git/forges GET/POST List/add git forges
/api/v1/git/repos GET/POST List/clone repositories
/api/v1/git/repos/{id}/sync POST Sync repository
/api/v1/skills GET/POST List/create skills
/api/v1/skills/{id}/execute POST Execute skill
/api/v1/automations GET/POST List/create automations
/api/v1/sandboxes GET/POST List/create sandboxes
/api/v1/sandboxes/{id}/exec POST Execute in sandbox
/api/v1/triage/analyze POST Analyze issue
/api/v1/cicd/status GET Get CI/CD status
/api/v1/devtoolbox/integrations GET/POST List/create integrations
/api/v1/devtoolbox/integrations/{id}/execute POST Execute integration workflow
/api/v1/devtoolbox/integrations/templates GET Get integration templates

Web Dashboard

Access DevToolBox features visually through the Data Worker dashboard.

Dashboard URL: http://dataworker:8892/dashboard/devtoolbox

The dashboard provides a visual interface for managing Git forges, skills, automations, sandboxes, issue triage, and CI/CD monitoring.