Traditional CI/CD pipelines execute predefined steps. NotSudo is an intelligent agent — it reads issues, understands intent, reasons about code, generates targeted fixes, validates them in sandboxed environments, and delivers production-ready pull requests. It bridges the gap between issue tracking and code delivery with zero manual intervention.

• Multi-LLM Support — Claude 3.5 Sonnet (via OpenRouter), GPT-4, Groq models with per-user model selection
• Agentic Code Analysis — Multi-turn AI reasoning with function calling for complex code changes
• Smart File Selection — Intelligently identifies relevant files from the entire codebase
• Custom Rules Engine — Define project-specific coding rules the AI follows during generation
• Codebase Memory — Persistent context storage per repository for improved AI decision-making

• AWS Fargate Sandbox — Isolated serverless containers for safe code execution in production
• Local Docker Sandbox — Container-based validation for development environments
• Full Stack Detection — Auto-detects Python (pip/poetry), Node.js (npm/yarn/pnpm), Java, Go, Rust
• Validation Pipeline — Dependency installation, test execution, type checking (TypeScript/MyPy), linting, security scanning
• Graceful Fallback — Fargate → Docker → Local execution chain

• Webhook-Driven — Real-time event processing for issue comments and PR feedback
• Automated PR Creation — Branch creation, code commits, and pull request generation
• GitHub App Support — OAuth-based authentication with installation tracking
• Webhook Signature Verification — Secure webhook validation
• Rate Limit Handling — Automatic backoff and retry logic

• Live Job Streaming — Socket.IO-powered real-time status updates and log streaming
• Job History & Analytics — Track all automation jobs with filtering and detailed views
• Repository Management — Connect repos, manage webhooks, view issues per repository
• Code Diff Viewer — Visual diff display for AI-generated changes
• User Settings — Per-user AI model selection, custom rules, account management

• OAuth Authentication — GitHub and Google OAuth via Better-Auth
• Subscription Management — Built-in payment processing with Dodo Payments
• PostgreSQL Support — Production-grade database with SQLAlchemy ORM
• Redis Job Queue — Async task processing with Redis message queue
• Security Scanning — Built-in vulnerability detection for generated code

┌─────────────────────────────────────────────────────────────────────┐
│                          NotSudo Platform                            │
├──────────────────────────┬──────────────────────────────────────────┤
│                          │                                          │
│   Frontend (Next.js 14)  │         Backend (Flask + Python)         │
│   ┌──────────────────┐   │   ┌──────────────────────────────────┐  │
│   │ Dashboard UI      │   │   │ Webhook Handler                  │  │
│   │ Job Monitor       │   │   │ AI Service (OpenRouter / Groq)   │  │
│   │ Repo Manager      │   │   │ GitHub Service (PyGithub)        │  │
│   │ Settings Panel    │   │   │ PR Service                       │  │
│   │ Code Diff Viewer  │   │   │ Code Execution Service           │  │
│   │ OAuth Flow        │◄──┼──►│ Security Scanner                 │  │
│   └──────────────────┘   │   │ Database Layer (SQLAlchemy)       │  │
│                          │   └────────────┬─────────────────────┘  │
│   Real-time: Socket.IO   │                │                        │
│                          │   ┌────────────▼─────────────────────┐  │
│                          │   │     Execution Sandboxes           │  │
│                          │   │  ┌───────┐ ┌────────┐ ┌───────┐  │  │
│                          │   │  │AWS    │ │Docker  │ │Local  │  │  │
│                          │   │  │Fargate│ │Container│ │Exec  │  │  │
│                          │   │  └───────┘ └────────┘ └───────┘  │  │
│                          │   └──────────────────────────────────┘  │
├──────────────────────────┴──────────────────────────────────────────┤
│  External Services: GitHub API · OpenRouter · Groq · AWS (ECS/S3/  │
│  CloudWatch/ECR) · Redis · PostgreSQL · Dodo Payments              │
└─────────────────────────────────────────────────────────────────────┘

GitHub Issue/PR Comment
        │
        ▼
  Webhook Handler ──► Verify Signature
        │
        ▼
  Queue Job (Redis)
        │
        ▼
  Fetch Codebase ──► Smart File Selection
        │
        ▼
  AI Analysis ──► Multi-turn LLM Reasoning (Claude / GPT-4 / Groq)
        │
        ▼
  Generate Code Changes ──► Function Calling (replace, insert, edit)
        │
        ▼
  Create Branch + Commit Changes
        │
        ▼
  Validate in Sandbox ──► AWS Fargate │ Docker │ Local
        │
        ▼
  Create Pull Request
        │
        ▼
  Stream Results ──► Socket.IO ──► Dashboard

• Python 3.11+
• Node.js 18+
• Redis (optional, for production job queue)
• Docker (optional, for local sandboxing)

git clone https://github.com/your-username/notsudo.git
cd notsudo

# Backend
cd backend
pip install -r requirements.txt

# Frontend
cd ../frontend
npm install

# Backend (.env)
OPENROUTER_API_KEY=your_openrouter_key
GITHUB_TOKEN=your_github_pat
GROQ_API_KEY=your_groq_key          # Optional
REDIS_URL=redis://localhost:6379     # Optional
DATABASE_URL=postgresql://...        # Optional, defaults to SQLite

# AWS Sandbox (Optional)
AWS_ACCESS_KEY_ID=your_key
AWS_SECRET_ACCESS_KEY=your_secret
AWS_REGION=us-east-1

# Terminal 1 - Backend
cd backend && python app.py

# Terminal 2 - Frontend
cd frontend && npm run dev

The dashboard will be available at http://localhost:3000 and the API at http://localhost:8000.

1. Open the dashboard and sign in with GitHub OAuth
2. Navigate to Repositories and connect your repos
3. Webhooks are automatically configured via the GitHub App
4. Comment @notsudo fix the login bug on any issue — the agent takes it from there

1. Trigger — A user mentions the bot in a GitHub issue or PR comment
2. Analyze — The agent fetches the repository structure and relevant files, then uses multi-turn LLM reasoning to understand the problem
3. Generate — AI generates targeted code changes using function calling (file edits, replacements, insertions)
4. Validate — Changes are tested in an isolated sandbox (AWS Fargate, Docker, or local) — running tests, type checks, linting, and security scans
5. Deliver — A pull request is created with the validated changes, complete with a detailed description
6. Monitor — The entire pipeline streams real-time updates to the dashboard via Socket.IO

• Multi-cloud sandbox support (Azure Container Instances, GCP Cloud Run)
• Kubernetes-native execution mode
• Slack / Discord notifications
• Jira and Linear integration
• Pre-PR approval workflows with human-in-the-loop
• Fine-tuned models for domain-specific codebases
• Plugin system for custom tools and integrations
• GitLab and Bitbucket support

Contributions are welcome! Please open an issue or submit a pull request.

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

Kakumanu Ashok Reddy — Full Stack & Cloud Developer

I built NotSudo end-to-end — from the AI agent pipeline and cloud sandbox infrastructure to the real-time dashboard. This project reflects my skills across:

Backend & Cloud: Python, Flask, SQLAlchemy, AWS (ECS Fargate, S3, ECR, CloudWatch, IAM, VPC), Docker, Redis, PostgreSQL, REST APIs, WebSockets (Socket.IO)

Frontend: Next.js 14, React, TypeScript, Tailwind CSS, Shadcn UI, Real-time UI with Socket.IO

AI/LLM Integration: OpenRouter, Groq, OpenAI API, function calling, multi-turn agentic workflows, prompt engineering

DevOps & Infrastructure: GitHub Apps & Webhooks, OAuth flows, CI/CD, containerized code execution, sandboxed validation pipelines

I'm open to work. If you're hiring for Full Stack, Cloud, AI/LLM, or DevOps roles — I'd love to connect.