An automated code fixing engine that transforms from "smart text search" into AI-powered code fixing with AST-based analysis, knowledge graphs, and validated solution generation. Delivers complete, tested fixes for technical debt and code quality issues.

• AI Code Fixing Platform
  • Table of Contents
  • ✨ Key Features
  • 🏗️ Tech Stack
  • 📂 Repository Layout (top-level)
  • 🚀 Quick Start (Production-like)
    • Local Development Hot-Reload
  • 🛠️ Backend Development
    • Environment Variables (partial list)
    • API Documentation
  • 🌐 Frontend Development
    • Regenerate Typed API Client
  • 🧪 Testing All Services
  • 🖥️ Makefile Cheat-Sheet
  • 🤝 Contributing
  • 📄 License

• Automated Code Fixing – AST-based problem detection with AI-generated solutions and comprehensive validation
• Knowledge Graph Analysis – understand code relationships, dependencies, and architectural patterns through Neo4j integration
• Multi-Modal Understanding – combines code structure, comments, tests, and documentation for complete context
• Fix Validation System – syntax, compilation, behavioral, and security validation ensuring safe code changes
• Hierarchical Code Summarization – semantic clustering from individual functions to system-wide architecture
• Program Dependence Graphs – control and data flow analysis for precise change impact prediction
• Incremental Analysis – real-time repository updates with smart caching and change propagation
• Repository-Level Reasoning – CodePlan-inspired planning for complex architectural queries and multi-step fixes
• GitHub OAuth Integration – secure repository access with automated import and progress tracking
• Type-Safe API – OpenAPI-first development with generated types for backend and frontend

backend/    # Go services, API, generation & Dockerfiles
frontend/   # SvelteKit application
mongodb-init/  # Mongo seed user scripts
Makefile    # helper commands (docker compose, build, test)
docker-compose[.dev].yml  # multi-service orchestration

The simplest way to spin everything up is Docker Compose:

# Build & start in the background
make up               # defaults to env=prod → docker-compose.yml

# Tail logs
make logs

# Shutdown
make down

The prod stack uses the regular Dockerfile images for both frontend and backend.

# Start dev versions (hot-reload, vite, go run, etc.)
make up env=dev       # uses docker-compose.dev.yml

Behind the scenes the dev compose file mounts your source directories and uses Dockerfile.dev images that have nodemon / reflex / vite dev servers.

cd backend

# Run unit tests with race detector & coverage
make test

# Lint & vet
make validate

# Hot-reload standalone (without docker)
make backend-dev

See backend/internal/config/config.go for the full configuration matrix.

Swagger-UI is automatically served at:

http://localhost:8080/docs/

The spec lives in backend/api/openapi.yaml. Convert to JSON via:

make -C backend openapi-json

cd frontend
bun install            # or npm / pnpm / yarn
cp .env.example .env.local
bun run dev            # localhost:3000

VITE_API_URL must point to the backend URL (defaults to http://localhost:8080).

bun run generate-api   # parses backend OpenAPI spec → src/lib/api/types.ts

Unit tests: bun run test:unit

E2E tests (Playwright): bun run test:e2e

1. Ensure MongoDB, Qdrant & Neo4j services are running (make up env=dev).
2. Run backend tests: make test.
3. Run frontend unit & e2e tests: cd frontend && bun run test.
4. Validate fix generation and AST analysis: make validate.

make up [env=dev|prod]       # build & start stack
make down [env=..]           # stop stack
make clean                   # down + remove volumes
make logs service=<name>     # follow logs
make generate                # go generate API stubs
make backend-dev             # run backend with hot reload

1. Fork & clone the repo.
2. Create a feature branch: git checkout -b feat/my-feature.
3. Run make validate to ensure code passes lints/tests.
4. Submit a pull request – please describe the motivation and include screenshots / logs where relevant.

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