ADES - AI Development Experience System

GAIT is not gait, It's AI in the GIT.

🚀 Overview

ADES (AI Development Experience System) is a revolutionary AI-powered platform that transforms how developers interact with their codebases. By combining advanced machine learning, semantic analysis, and intelligent automation, ADES provides unprecedented insights into development patterns, code quality, and team collaboration.

🎯 What Makes ADES Special?

🧠 AI-Powered Analysis: Advanced ML algorithms analyze your entire codebase to extract patterns, detect anomalies, and predict trends
🔍 Semantic Understanding: Deep semantic analysis of commits, code changes, and development intent
🤝 Real-time Collaboration: Live collaboration features with presence tracking and shared analysis
🎨 Interactive Visualizations: Rich dashboards and charts for code metrics, team activity, and quality trends
🔌 IDE Integration: Seamless integration with popular IDEs for real-time code assistance
📊 Comprehensive Analytics: Detailed insights into code quality, technical debt, and team productivity
🚀 Production Ready: Enterprise-grade deployment with Docker, Kubernetes, and CI/CD pipelines

✨ Features

🧠 Core AI Capabilities

Semantic Analysis Engine

Intent Classification: Automatically categorizes commits by development intent (feature, bugfix, refactor, etc.)
Topic Modeling: Extracts key topics and themes from code changes
Similarity Matching: Finds similar implementations and patterns across your codebase
Context Understanding: Deep understanding of code context and relationships

Machine Learning Pipeline

Pattern Recognition: Identifies reusable code patterns and design patterns
Anomaly Detection: Detects unusual code changes, potential bugs, and security issues
Trend Prediction: Predicts development trends, technical debt, and quality metrics
Quality Assessment: Automated code quality scoring and improvement suggestions

Knowledge Graph System

Relationship Mapping: Maps relationships between code components, developers, and concepts
Knowledge Discovery: Discovers hidden connections and dependencies
Graph Queries: Advanced querying capabilities for complex code relationships
Insight Generation: Generates actionable insights from code relationships

🔧 Development Tools

Automated Code Review

Multi-dimensional Analysis: Quality, security, performance, and pattern analysis
Intelligent Suggestions: ML-powered code improvement recommendations
Severity Classification: Automatic prioritization of issues and suggestions
Integration Ready: Works with existing CI/CD pipelines

IDE Integration

Real-time Analysis: Live code analysis as you type
Smart Completion: AI-powered code completion with context awareness
Inline Hints: Intelligent suggestions and warnings directly in your editor
Multi-IDE Support: VSCode, IntelliJ IDEA, Vim, Emacs, Sublime Text

Collaboration Features

Real-time Presence: See who's working on what in real-time
Shared Analysis: Collaborate on code analysis and insights
Team Insights: Team productivity and collaboration metrics
Knowledge Sharing: Share patterns and insights across the team

📊 Analytics & Visualization

Interactive Dashboards

14+ Widget Types: Charts, tables, metrics, gauges, heatmaps, and more
Real-time Updates: Live data updates via WebSocket connections
Customizable Layouts: Drag-and-drop dashboard creation
Export Capabilities: Export dashboards as PNG, PDF, CSV, or JSON

Comprehensive Metrics

Code Quality Trends: Track quality improvements over time
Team Activity: Developer productivity and contribution analysis
Technical Debt: Identify and track technical debt accumulation
Performance Insights: Code performance and optimization opportunities

🔌 Integration Ecosystem

MCP (Model Context Protocol) Support

AI Assistant Integration: Works with Cursor, Claude, ChatGPT, and other AI assistants
11 Specialized Tools: Search experiences, extract patterns, analyze semantics, and more
Context Provision: Rich context for AI-powered development assistance
WebSocket & HTTP: Flexible communication protocols
Cursor Integration: Seamless integration with Cursor IDE for enhanced AI coding assistance

API-First Design

RESTful APIs: 20+ endpoints for all ADES functionality
GraphQL Support: Advanced querying capabilities
Webhook Integration: Real-time notifications and integrations
Rate Limiting: Enterprise-grade API protection

🏗 Architecture

ADES follows a modular, microservices-inspired architecture designed for scalability and maintainability:

┌─────────────────────────────────────────────────────────────┐
│                    ADES Architecture                        │
├─────────────────────────────────────────────────────────────┤
│  Web UI  │  IDE Plugins  │  Mobile App  │  API Clients      │
├─────────────────────────────────────────────────────────────┤
│                    API Gateway                              │
├─────────────────────────────────────────────────────────────┤
│  Core Services                                              │
│  ┌─────────────┬─────────────┬─────────────┬─────────────┐  │
│  │   Semantic  │     ML      │ Knowledge   │    MCP      │  │
│  │   Analysis  │   Engine    │   Graph     │   Server    │  │
│  └─────────────┴─────────────┴─────────────┴─────────────┘  │
├─────────────────────────────────────────────────────────────┤
│  Integration Layer                                          │
│  ┌─────────────┬─────────────┬─────────────┬─────────────┐  │
│  │     Git     │    IDE      │Collaboration│Visualization│  │
│  │ Integration │Integration  │   Server    │  Dashboard  │  │
│  └─────────────┴─────────────┴─────────────┴─────────────┘  │
├─────────────────────────────────────────────────────────────┤
│  Data Layer                                                 │
│  ┌─────────────┬─────────────┬─────────────┬─────────────┐  │
│  │   SQLite    │   Vector    │    Redis    │ File System │  │
│  │  Database   │  Database   │    Cache    │   Storage   │  │
│  └─────────────┴─────────────┴─────────────┴─────────────┘  │
└─────────────────────────────────────────────────────────────┘

Core Components

Semantic Analysis Engine: Processes code semantics and intent
ML Pipeline: Pattern recognition, anomaly detection, trend prediction
Knowledge Graph: Relationship mapping and insight generation
MCP Server: AI assistant integration and context provision
IDE Integration: Real-time editor integration and assistance
Collaboration Server: Real-time team collaboration features
Visualization Dashboard: Interactive charts and analytics

🚀 Quick Start

Prerequisites

Go 1.22+
Git
Docker (optional, for containerized deployment)
Node.js 18+ (for web UI development)

1. Clone and Build

# Clone the repository
git clone https://github.com/knoxai/gait.git
cd gait

# Build the application
go build -o ades .

# Run ADES
./ades -port 8080

2. Access ADES

Open your browser and navigate to:

Main UI: http://localhost:8080
IDE Integration: http://localhost:8081
Collaboration: http://localhost:8082
Visualization: http://localhost:8083
API Documentation: http://localhost:8080/api/docs
Metrics: http://localhost:8080/metrics

3. Analyze Your First Repository

# Initialize ADES with your repository
curl -X POST "http://localhost:8080/api/repositories" \
  -H "Content-Type: application/json" \
  -d '{"path": "/path/to/your/repo", "name": "my-project"}'

# Start comprehensive analysis
curl -X POST "http://localhost:8080/api/ades/analyze/comprehensive" \
  -H "Content-Type: application/json" \
  -d '{"async": false}'

4. Enable Cursor MCP Integration

# Start the MCP server for Cursor integration
./start-mcp-server.sh

# Test the integration
./test-mcp-integration.sh

# The workspace is pre-configured for Cursor MCP integration
# Restart Cursor to activate the ADES tools

Available MCP Tools in Cursor:

search_development_experience - Find similar development patterns
get_similar_implementations - Discover related code implementations
extract_reusable_patterns - Identify reusable code patterns
analyze_commit_semantics - Understand commit intent and meaning
get_commit_details - Get comprehensive commit information
get_commit_history - Retrieve filtered commit history
And 5 more powerful analysis tools!

See MCP_INTEGRATION.md for detailed setup instructions.

📦 Installation

Option 1: Binary Installation

# Download the latest release
wget https://github.com/knoxai/gait/releases/latest/download/ades-linux-amd64.tar.gz

# Extract and install
tar -xzf ades-linux-amd64.tar.gz
sudo mv ades /usr/local/bin/

# Verify installation
ades --version

Option 2: Docker Installation

# Pull the Docker image
docker pull ghcr.io/knoxai/ades:latest

# Run with Docker
docker run -d \
  --name ades \
  -p 8080:8080 \
  -p 8081:8081 \
  -p 8082:8082 \
  -p 8083:8083 \
  -v $(pwd)/data:/app/data \
  -v $(pwd)/repositories:/app/repositories:ro \
  ghcr.io/knoxai/ades:latest

Option 3: Docker Compose (Recommended for Development)

# Clone the repository
git clone https://github.com/knoxai/gait.git
cd gait

# Start all services
docker-compose up -d

# Services will be available at:
# - ADES: http://localhost:8080
# - Redis: localhost:6379
# - PostgreSQL: localhost:5432
# - Prometheus: http://localhost:9090
# - Grafana: http://localhost:3000

Option 4: Kubernetes Deployment

# Deploy to Kubernetes
kubectl apply -f deployments/kubernetes/

# Or use the automated deployment script
./deployments/scripts/deploy.sh

⚙️ Configuration

ADES uses a JSON configuration file located at data/ades-config.json. Here's a sample configuration:

{
  "server": {
    "port": 8080,
    "host": "0.0.0.0"
  },
  "semantic": {
    "enabled": true,
    "embedding_dimension": 384,
    "similarity_threshold": 0.7
  },
  "ml": {
    "enabled": true,
    "pattern_recognition_engine": "advanced",
    "classification_threshold": 0.7,
    "anomaly_detection_enabled": true,
    "trend_prediction_enabled": true
  },
  "ide_integration": {
    "enabled": true,
    "port": 8081,
    "supported_ides": ["vscode", "intellij", "vim", "emacs", "sublime"],
    "enable_real_time_analysis": true,
    "enable_code_completion": true
  },
  "collaboration": {
    "enabled": true,
    "websocket_port": 8082,
    "max_concurrent_users": 50,
    "enable_shared_analysis": true
  },
  "visualization": {
    "enabled": true,
    "dashboard_port": 8083,
    "enable_real_time_charts": true,
    "chart_types": ["line", "bar", "pie", "scatter", "heatmap", "network"]
  }
}

Environment Variables

Variable	Description	Default
`ADES_PORT`	Main application port	`8080`
`ADES_DATA_DIR`	Data directory path	`./data`
`ADES_CONFIG_PATH`	Configuration file path	`./data/ades-config.json`
`ADES_LOG_LEVEL`	Logging level	`info`
`ADES_ENABLE_METRICS`	Enable metrics collection	`true`

📚 API Documentation

ADES provides a comprehensive RESTful API with 20+ endpoints:

Core Endpoints

# Repository Management
GET    /api/repositories          # List repositories
POST   /api/repositories          # Add repository
GET    /api/repositories/{id}     # Get repository details

# Analysis
POST   /api/ades/analyze/comprehensive  # Comprehensive analysis
GET    /api/ades/analyze/progress       # Analysis progress
GET    /api/commits                     # List commits
GET    /api/commits/{hash}              # Get commit details

# Semantic Analysis
POST   /api/semantic/analyze      # Analyze semantics
GET    /api/semantic/similar      # Find similar commits
POST   /api/semantic/search       # Semantic search

# Machine Learning
GET    /api/ml/patterns           # Get detected patterns
GET    /api/ml/anomalies          # Get anomalies
GET    /api/ml/trends             # Get trend predictions

# Knowledge Graph
GET    /api/knowledge/nodes       # Get graph nodes
GET    /api/knowledge/relationships  # Get relationships
POST   /api/knowledge/query       # Query knowledge graph

MCP Tools

ADES provides 6 specialized MCP tools for AI assistant integration:

search_development_experience - Search similar development experiences
get_similar_implementations - Find similar implementations by commit
extract_reusable_patterns - Extract reusable code patterns
analyze_commit_semantics - Detailed semantic analysis of commits
query_knowledge_graph - Query development knowledge graph
get_development_insights - Comprehensive development insights

🔌 IDE Integration

Visual Studio Code

# Install the ADES extension (coming soon)
code --install-extension ades.ades-vscode

# Or install manually from .vsix file
code --install-extension ades-vscode-1.0.0.vsix

IntelliJ IDEA

# Install from JetBrains Marketplace (coming soon)
# Or install manually from .jar file

Vim/Neovim

" Add to your .vimrc or init.vim
Plug 'knoxai/ades-vim'

Configuration

All IDE plugins connect to the ADES server running on port 8081:

{
  "ades.server.url": "http://localhost:8081",
  "ades.realtime.enabled": true,
  "ades.completion.enabled": true,
  "ades.hints.enabled": true
}

🚀 Deployment

Production Deployment with Kubernetes

# 1. Build and push Docker image
docker build -t your-registry/ades:latest .
docker push your-registry/ades:latest

# 2. Update deployment configuration
sed -i 's|image: ades:latest|image: your-registry/ades:latest|g' deployments/kubernetes/deployment.yaml

# 3. Deploy to Kubernetes
kubectl apply -f deployments/kubernetes/

# 4. Verify deployment
kubectl get pods -n ades-system
kubectl get services -n ades-system

Scaling Configuration

# Horizontal Pod Autoscaler
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: ades-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: ades-deployment
  minReplicas: 3
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

Monitoring and Observability

ADES includes comprehensive monitoring:

Prometheus Metrics: Available at /metrics endpoint
Health Checks: Available at /api/health endpoint
Structured Logging: JSON format with configurable levels
Performance Metrics: Response times, throughput, error rates
Business Metrics: Analysis counts, user activity, system usage

🧪 Development

Setting up Development Environment

# Clone the repository
git clone https://github.com/knoxai/gait.git
cd gait

# Install dependencies
go mod download

# Run tests
go test ./...

# Run with hot reload (requires air)
go install github.com/cosmtrek/air@latest
air

# Build for development
go build -o ades-dev .
./ades-dev -port 8080

Project Structure

gait/
├── cmd/                    # Command-line interfaces
├── internal/               # Internal packages
│   ├── ades/              # Core ADES functionality
│   │   ├── analyzer/      # Code analysis
│   │   ├── batch/         # Batch processing
│   │   ├── collaboration/ # Real-time collaboration
│   │   ├── config/        # Configuration management
│   │   ├── ide/           # IDE integration
│   │   ├── knowledge/     # Knowledge graph
│   │   ├── mcp/           # MCP server
│   │   ├── ml/            # Machine learning
│   │   ├── models/        # Data models
│   │   ├── monitoring/    # Monitoring and metrics
│   │   ├── patterns/      # Pattern extraction
│   │   ├── performance/   # Performance optimization
│   │   ├── review/        # Code review
│   │   ├── security/      # Security features
│   │   ├── semantic/      # Semantic analysis
│   │   ├── storage/       # Data storage
│   │   ├── vector/        # Vector operations
│   │   └── visualization/ # Dashboard and charts
│   ├── api/               # API handlers
│   ├── git/               # Git integration
│   └── web/               # Web interface
├── pkg/                   # Public packages
├── deployments/           # Deployment configurations
│   ├── kubernetes/        # Kubernetes manifests
│   ├── scripts/           # Deployment scripts
│   └── docker/            # Docker configurations
├── static/                # Static web assets
├── templates/             # HTML templates
└── docs/                  # Documentation

Running Tests

# Run all tests
go test ./...

# Run tests with coverage
go test -cover ./...

# Run specific test package
go test ./internal/ades/semantic/

# Run integration tests
go test -tags=integration ./...

# Benchmark tests
go test -bench=. ./...

🤝 Contributing

We welcome contributions to ADES! Please see our Contributing Guide for details.

Development Workflow

Fork the repository
Create a feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

Code Standards

Go: Follow standard Go conventions and use gofmt
Testing: Maintain >80% test coverage
Documentation: Document all public APIs
Commits: Use conventional commit messages

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

Go Community for the excellent ecosystem
ChromaDB for vector database capabilities
Prometheus for monitoring and metrics
Kubernetes for orchestration platform
All Contributors who have helped build ADES

📞 Support

Documentation: docs.knox.chat
Issues: GitHub Issues
Discussions: GitHub Discussions
Email: [email protected]

ADES - Transforming Development Experience with AI 🚀

Made with ❤️ by the ADES Team

Name		Name	Last commit message	Last commit date
Latest commit History 16 Commits
.cursor		.cursor
.gait		.gait
.vscode		.vscode
cmd/mcp-server		cmd/mcp-server
deployments		deployments
extensions/vscode		extensions/vscode
internal		internal
pkg/types		pkg/types
.gitignore		.gitignore
Dockerfile		Dockerfile
GIT_OPERATIONS_SUMMARY.md		GIT_OPERATIONS_SUMMARY.md
LICENSE		LICENSE
README.md		README.md
README_zh.md		README_zh.md
benchmark.sh		benchmark.sh
build.sh		build.sh
debug.sh		debug.sh
diagnose-mcp.sh		diagnose-mcp.sh
docker-compose.yml		docker-compose.yml
go.mod		go.mod
go.sum		go.sum
main.go		main.go
mcp-config.json		mcp-config.json
start-mcp-server.sh		start-mcp-server.sh

License

knoxai/gait

Folders and files

Latest commit

History

Repository files navigation