SamyRai/juleson

Juleson/
├── cmd/                          # Application entry points
│   ├── juleson/                 # CLI tool for direct usage
│   ├── juleson-mcp/             # MCP server for AI assistants
│   └── orchestrator/            # Build orchestrator
├── internal/
│   ├── agent/                   # 🤖 Intelligent AI Agent System
│   │   ├── core/                # Agent loop (perceive→plan→act→review→reflect)
│   │   ├── github/              # GitHub integration for agents
│   │   ├── memory/              # Learning and memory system
│   │   ├── review/              # Code review automation
│   │   ├── tools/               # Tool registry and implementations
│   │   └── types.go             # Agent state and goal definitions
│   ├── analyzer/                # 🔍 Advanced Code Intelligence
│   │   ├── analyzer.go          # Project analysis engine
│   │   ├── quality.go           # Code quality assessment
│   │   └── analyzer_test.go     # Test coverage analysis
│   ├── automation/              # 🎨 AI Orchestration Engine
│   │   ├── ai_orchestrator.go   # Multi-step workflow orchestration
│   │   ├── engine.go            # Task execution & dependency management
│   │   └── engine_test.go       # Orchestration testing
│   ├── cli/                     # ⚙️ CLI Implementation (20+ commands)
│   │   ├── app.go               # Main CLI application
│   │   └── commands/            # Command implementations
│   │       ├── actions.go       # Action management
│   │       ├── activities.go    # Activity monitoring
│   │       ├── agent.go         # 🤖 Agent commands
│   │       ├── ai_orchestrate.go # 🎨 AI orchestration
│   │       ├── analyze.go       # 🔍 Analysis commands
│   │       ├── completion.go    # Shell completion
│   │       ├── dev.go           # Development tools
│   │       ├── display.go       # Display utilities
│   │       ├── execute.go       # Template execution
│   │       ├── github.go        # 🐙 GitHub integration
│   │       ├── orchestrate.go   # Workflow orchestration
│   │       ├── pr.go            # Pull request management
│   │       ├── sessions.go      # 💬 Session management
│   │       ├── setup.go         # Initial setup
│   │       ├── sources.go       # Source management
│   │       ├── sync.go          # Project synchronization
│   │       ├── template.go      # 📋 Template management
│   │       └── version.go       # Version information
│   ├── codeintel/               # 🔍 Code Intelligence Engine
│   │   ├── context/             # Code context analysis
│   │   ├── graph/               # Call graph building
│   │   ├── static/              # Static analysis runner
│   │   └── types.go             # Code intelligence types
│   ├── config/                  # Configuration management
│   │   └── config.go            # YAML + environment variables
│   ├── events/                  # 📡 Event-Driven Architecture
│   │   ├── bus.go               # Pub/sub event bus
│   │   ├── circuit_breaker.go   # Fault tolerance
│   │   ├── coordinator.go       # Event coordination
│   │   ├── doc.go               # Event documentation
│   │   ├── middleware.go        # Event processing middleware
│   │   ├── queue.go             # Message queues
│   │   ├── store.go             # Event persistence
│   │   └── types.go             # Event definitions
│   ├── gemini/                  # 🎨 Gemini AI Integration
│   │   └── client.go            # Gemini API client
│   ├── github/                  # 🐙 GitHub API Integration
│   │   ├── actions.go           # GitHub Actions
│   │   ├── client.go            # GitHub API client
│   │   ├── git.go               # Git operations
│   │   ├── issues.go            # Issue management
│   │   ├── milestones.go        # Milestone management
│   │   ├── projects.go          # Project management
│   │   ├── pullrequests.go      # PR management
│   │   ├── repositories.go      # Repository operations
│   │   ├── sessions.go          # Session integration
│   │   ├── types.go             # GitHub types
│   │   └── utils.go             # Utility functions
│   ├── jules/                   # Jules API Integration
│   │   ├── client.go            # HTTP client & retry logic
│   │   ├── sessions.go          # Session management (CRUD)
│   │   ├── activities.go        # Activity monitoring
│   │   ├── artifacts.go         # Artifact handling
│   │   └── monitor.go           # Real-time session monitoring
│   ├── mcp/                     # 🔌 MCP Server Implementation
│   │   ├── server.go            # Official SDK integration
│   │   └── tools/               # MCP tool implementations
│   │       ├── codeintel.go     # 🔍 Code intelligence tools
│   │       ├── docker.go        # Docker management tools
│   │       ├── gemini.go        # 🎨 Gemini AI tools
│   │       ├── github.go        # 🐙 GitHub tools
│   │       └── orchestrator.go  # 🎨 Orchestration tools
│   ├── orchestrator/            # Build Orchestration
│   │   ├── build.go             # Build orchestration
│   │   ├── deps.go              # Dependency management
│   │   ├── docker.go            # Docker operations
│   │   ├── quality.go           # Quality checks
│   │   ├── run.go               # Execution orchestration
│   │   └── test.go              # Test orchestration
│   ├── presentation/            # Display & Formatting
│   ├── services/                # Service Container & DI
│   │   └── container.go         # Application services
│   └── templates/               # 📋 Template Management
│       └── manager.go           # Template CRUD & validation
├── docs/                        # 📚 Comprehensive Documentation
│   ├── AGENT_ARCHITECTURE.md
│   ├── AGENT_ARCHITECTURE_CODE_REVIEW.md
│   ├── AGENT_PRODUCTION_FEATURES.md
│   ├── AI_ORCHESTRATION.md
│   ├── CLI_REFERENCE.md
│   ├── CODE_INTELLIGENCE.md
│   ├── DEPLOYMENT_GUIDE.md
│   ├── DX_IMPROVEMENTS.md
│   ├── EVENT_SYSTEM_ARCHITECTURE.md
│   ├── EVENT_SYSTEM_QUICKSTART.md
│   ├── GITHUB_ACTIONS_GUIDE.md
│   ├── GITHUB_CONFIGURATION_GUIDE.md
│   ├── GITHUB_INTEGRATION_PROPOSAL.md
│   ├── INSTALLATION_GUIDE.md
│   ├── MCP_SERVER_USAGE.md
│   ├── ORCHESTRATOR_ARCHITECTURE.md
│   ├── README.md
│   ├── SETUP_GUIDE.md
│   └── docs/
├── templates/                   # 📋 Automation Templates
│   ├── builtin/                # 12 production templates
│   │   ├── reorganization/     # Architecture refactoring
│   │   ├── testing/            # Test generation
│   │   ├── refactoring/        # Code improvement
│   │   └── documentation/      # Doc generation
│   ├── custom/                 # User-defined templates
│   └── registry/               # Template metadata
├── configs/                     # Configuration files
│   └── Juleson.yaml            # Default configuration
├── scripts/                     # Demo scripts
│   ├── ai_parsing_demo_only.go
│   └── session_orchestrator_poc.go
└── docker-compose.yml           # 🐳 Development environment

# Using Go (requires Go 1.24+)
go install github.com/SamyRai/juleson/cmd/juleson@latest
go install github.com/SamyRai/juleson/cmd/juleson-mcp@latest

# Using Go (requires Go 1.24+)
go install github.com/SamyRai/juleson/cmd/juleson@latest
go install github.com/SamyRai/juleson/cmd/juleson-mcp@latest

# Clone the repository
git clone https://github.com/SamyRai/juleson.git
cd juleson

# Install dependencies
go mod download

# Configure your API key
export JULES_API_KEY="your-jules-api-key-here"

# Optional: Configure Gemini and GitHub
export GEMINI_API_KEY="your-gemini-api-key"  # For AI orchestration
export GITHUB_TOKEN="ghp_your_github_token"  # For GitHub integration

# Build the orchestrator first
go build -o bin/orchestrator ./cmd/orchestrator

# Build binaries using orchestrator
./bin/orchestrator build

# Install to system
./bin/juleson dev install

# Verify installation
juleson --version
juleson-mcp --version

# First-time setup (recommended)
juleson setup

# Or configure manually
export JULES_API_KEY="your-jules-api-key"
export GITHUB_TOKEN="ghp_your_github_token"  # Optional, for GitHub integration

# Verify setup
juleson github status
juleson sessions list

# First-time setup (recommended)
juleson setup

# 🤖 Agent Commands
juleson agent run "analyze and refactor this codebase"  # Run AI agent
juleson agent status                                    # Check agent status
juleson agent memory                                    # View agent memory

# 🔍 Analysis Commands
juleson analyze ./my-project                            # Analyze project structure
juleson ai-orchestrate plan ./my-project                # AI-powered project planning

# 📋 Template Operations
juleson template list                                   # List available templates
juleson template list reorganization                     # Filter by category
juleson execute template modular-restructure ./my-project # Execute template

# 💬 Session Management
juleson sessions list                                   # List all Jules sessions
juleson sessions status                                 # Show session summary
juleson sessions approve session-123                     # Approve session plan
juleson sessions apply session-123 ./my-project         # Apply session patches

# 🐙 GitHub Integration
juleson github repos                                    # List your repositories
juleson github current                                  # Show current repo
juleson pr list                                         # List pull requests
juleson pr merge session-123                            # Merge a PR

# 🎨 AI Orchestration
juleson orchestrate workflow "refactor-monolith" ./my-project # Multi-step workflow
juleson actions list                                     # List available actions

# 🔧 Development Tools
juleson dev build                                       # Build project
juleson dev test                                        # Run tests
juleson dev quality                                     # Run quality checks

# Search and Utilities
juleson template search "test coverage"                 # Search templates
juleson template create my-template refactoring "Description" # Create custom template

./bin/juleson-mcp

{
  "mcpServers": {
    "Juleson": {
      "command": "/absolute/path/to/Juleson/bin/juleson-mcp",
      "env": {
        "JULES_API_KEY": "your-api-key"
      }
    }
  }
}

{
  "mcp.servers": {
    "Juleson": {
      "command": "/absolute/path/to/Juleson/bin/juleson-mcp",
      "env": {
        "JULES_API_KEY": "your-api-key"
      }
    }
  }
}

# Analyze project
./bin/juleson analyze ./my-go-app

# List reorganization templates
./bin/juleson template list reorganization

# Execute modular restructure template
./bin/juleson execute template modular-restructure ./my-go-app

# Execute test generation template
./bin/juleson execute template test-generation ./my-project

# Or improve existing coverage
./bin/juleson execute template test-coverage-improvement ./my-project

# List all active sessions
./bin/juleson sessions list

# Get status summary
./bin/juleson sessions status

# Monitor a specific session (via Jules API)
# The session ID will be in the execute template output

# Preview what changes a Jules session would make (dry-run)
./bin/juleson sessions preview session-123 ./my-project

# Apply patches from Jules session to your project
./bin/juleson sessions apply session-123 ./my-project

# Apply with backup files (creates .backup files before modifying)
./bin/juleson sessions apply session-123 ./my-project --backup

# Create a custom template
./bin/juleson template create api-versioning refactoring \
  "Add API versioning to existing REST endpoints"

# Edit the generated template file
# templates/custom/refactoring/api-versioning.yaml

# Execute your custom template
./bin/juleson execute template api-versioning ./my-api-project

# Run an intelligent agent to analyze and improve your codebase
juleson agent run "analyze this Go project and suggest refactoring improvements"

# Check agent status and progress
juleson agent status

# View agent's learned patterns and decisions
juleson agent memory

# Use AI orchestration for complex multi-step tasks
juleson ai-orchestrate plan ./my-project
juleson orchestrate workflow "comprehensive-refactor" ./my-project

# Analyze code complexity and quality metrics
juleson analyze complexity ./my-project

# Find all references to a specific function
juleson analyze references "func ProcessData" ./my-project

# Build and analyze call graphs
juleson analyze graph ./my-project

# Run comprehensive static analysis
juleson analyze static ./my-project

jules:
  api_key: ""  # Or use JULES_API_KEY environment variable
  base_url: "https://jules.googleapis.com/v1alpha"
  timeout: "30s"
  retry_attempts: 3

mcp:
  server:
    port: 8080
    host: "localhost"
  client:
    timeout: "10s"

automation:
  strategies:
    - "modular"
    - "layered"
    - "microservices"
  max_concurrent_tasks: 5
  task_timeout: "300s"

projects:
  default_path: "./projects"
  backup_enabled: true
  git_integration: true

# Required
export JULES_API_KEY="your-jules-api-key"

# Optional (with defaults)
export JULES_BASE_URL="https://jules.googleapis.com/v1alpha"
export JULES_TIMEOUT="30s"
export JULES_RETRY_ATTEMPTS="3"

# Build orchestrator first
go build -o bin/orchestrator ./cmd/orchestrator

# Run all tests
./bin/orchestrator test

# Run with coverage
./bin/orchestrator coverage

# Run specific package tests
go test -v ./internal/jules/...
go test -v ./internal/mcp/...

# Short tests only (exclude integration tests)
./bin/orchestrator test-short

# Format code
./bin/orchestrator fmt

# Run linters
./bin/orchestrator lint

# Run all checks (fmt + lint + test)
./bin/orchestrator check

# Build both binaries
./bin/orchestrator build

# Build CLI only
./bin/orchestrator build-cli

# Build MCP server only
./bin/orchestrator build-mcp

# Install to $GOPATH/bin
./bin/orchestrator install

// Create a Jules client
client := jules.NewClient(apiKey, baseURL, timeout, retryAttempts)

// Session management
session, err := client.CreateSession(ctx, &jules.CreateSessionRequest{
    Prompt: "Refactor this project to use clean architecture",
    Title:  "Architecture Refactoring",
    SourceContext: &jules.SourceContext{Source: "./my-project"},
})

// List sessions with pagination
response, err := client.ListSessionsWithPagination(ctx, 50, "")

// Get session details
session, err := client.GetSession(ctx, sessionID)

// Approve session plan
err := client.ApprovePlan(ctx, sessionID)

// Send message to session
err := client.SendMessage(ctx, sessionID, "Please add error handling")

// Apply patches from session to working directory
result, err := client.ApplySessionPatches(ctx, sessionID, &jules.PatchApplicationOptions{
    WorkingDir:   "./my-project",
    DryRun:       false,
    CreateBackup: true,
})

// Preview session changes (dry-run)
changes, err := client.PreviewSessionPatches(ctx, sessionID, "./my-project")

// Get session changes summary
changes, err := client.GetSessionChanges(ctx, sessionID)

// Activity monitoring
activities, err := client.ListActivities(ctx, sessionID, 100)

// Create automation engine
engine := automation.NewEngine(julesClient, templateManager)

// Analyze project
context, err := engine.AnalyzeProject("./my-project")

// Execute template
result, err := engine.ExecuteTemplate(ctx, "modular-restructure", map[string]string{
    "target_architecture": "clean",
    "preserve_tests": "true",
})

// Create template manager
manager, err := templates.NewManager("./templates")

// Load template
template, err := manager.LoadTemplate("modular-restructure")

// List all templates
templates := manager.ListTemplates()

// Search templates
results := manager.SearchTemplates("test coverage")

// Create custom template
template, err := manager.CreateTemplate("my-template", "refactoring", "Description")

# Clone your fork
git clone https://github.com/SamyRai/Juleson.git
cd Juleson

# Install dependencies
go mod download

# Build orchestrator
go build -o bin/orchestrator ./cmd/orchestrator

# Run tests
./bin/orchestrator test

# Build
./bin/orchestrator build

Copyright (c) 2025 Juleson Contributors

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software...