🐸 CodeFrog AI

Your AI Software Engineer for GitHub

Jump into your GitHub codebase. Build, fix, test, and ship faster.

CodeFrog AI is an AI-powered developer platform that connects with GitHub repositories and acts like an intelligent software engineer.

Instead of only answering coding questions, CodeFrog understands an entire codebase, analyzes files and dependencies, identifies bugs and security issues, generates code changes, runs tests, and creates Pull Requests for developer approval.

🚀 What is CodeFrog AI?

Modern software projects can contain hundreds or thousands of files. Understanding where a problem exists, which files are affected, and how to safely fix it can take a lot of time.

CodeFrog AI is designed to make this process faster.

A developer can connect a GitHub repository and simply tell CodeFrog what they want:

"Find all APIs without authentication and fix them."

CodeFrog can then:

Understand the request
        ↓
Analyze the repository
        ↓
Find relevant files
        ↓
Identify the problem
        ↓
Create a fix plan
        ↓
Generate code changes
        ↓
Show the developer a diff
        ↓
Run tests
        ↓
Run security checks
        ↓
Ask for human approval
        ↓
Create a Git branch
        ↓
Commit the changes
        ↓
Create a Pull Request

The developer remains in control of the final changes.

🎯 Vision

CodeFrog AI aims to become an AI Software Engineer for GitHub repositories.

The goal is not to build another coding chatbot.

The goal is to build an agent that can:

Understand a complete codebase
Search and analyze source code
Detect bugs
Find security vulnerabilities
Suggest and generate fixes
Generate tests
Run tests
Review code
Modify files
Create branches
Commit changes
Create Pull Requests

Core idea

CodeFrog doesn't just tell you what to change. It can understand the repository, prepare the change, test it, and submit it for your review.

🐸 Why "CodeFrog"?

The name represents the core idea behind the product.

Frog → Jump

CodeFrog can "jump into" a developer's GitHub repository and work with the codebase.

Code → Software

The platform understands and works with source code, APIs, dependencies, tests, and project architecture.

AI → Intelligent Engineer

AI analyzes the repository and performs development tasks using specialized tools.

Brand statement

CodeFrog AI — Jump into your codebase. Ship faster.

⭐ Core Features

1. 🔗 GitHub Integration

Connect your GitHub account and select the repository you want CodeFrog to work with.

Planned capabilities

GitHub OAuth
Repository selection
Repository file access
GitHub API integration
GitHub Webhooks
Branch management
Commit creation
Pull Request creation

2. 🤖 AI Developer Chat

CodeFrog provides an AI interface where developers can ask questions about their actual codebase.

Example questions:

How does authentication work?

Where is task creation implemented?

Which API handles user registration?

Explain this controller.

Why is this function slow?

How does data move from frontend to backend?

The AI answers using relevant code from the connected repository rather than relying only on generic programming knowledge.

3. 🧠 Codebase Understanding with RAG

Large repositories can contain hundreds or thousands of files.

Sending the entire repository to an LLM for every request would be inefficient.

CodeFrog uses a Retrieval-Augmented Generation architecture.

Repository indexing flow

GitHub Repository
        ↓
Repository Parser
        ↓
Code Files
        ↓
Chunking
        ↓
Embeddings
        ↓
Vector Database
        ↓
Retriever
        ↓
Relevant Code
        ↓
LLM
        ↓
AI Response

For example, if a developer asks:

"How does authentication work?"

CodeFrog can retrieve relevant files such as:

Login.jsx
authController.js
authService.js
authMiddleware.js
User.js

Instead of sending the entire repository to the model.

4. 🛠️ AI Software Engineer Agent

The Core Feature

The AI Agent is the heart of CodeFrog AI.

A developer can give the agent a high-level software engineering task.

For example:

Find all APIs that don't have authentication and fix them.

The agent can break this request into multiple steps.

User Request
      ↓
Understand Task
      ↓
Analyze Repository
      ↓
Find Relevant Files
      ↓
Identify Problem
      ↓
Create Fix Plan
      ↓
Generate Changes
      ↓
Run Tests
      ↓
Security Check
      ↓
Show Diff
      ↓
Human Approval
      ↓
Create Branch
      ↓
Commit Changes
      ↓
Create Pull Request

This makes CodeFrog an agentic software development system rather than a simple chatbot.

5. 🔍 Security Analysis

CodeFrog can analyze repositories for common security problems.

Example requests:

Find IDOR vulnerabilities.

Find APIs without authentication.

Find hardcoded secrets.

Check insecure CORS configuration.

Find missing authorization checks.

Example result:

🔍 Security Analysis

Found 5 potentially unprotected endpoints:

1. GET /api/users
2. GET /api/tasks
3. POST /api/submissions
4. GET /api/reports
5. DELETE /api/tasks/:id

The agent can explain why each issue may be dangerous and suggest an appropriate fix.

6. 🐛 AI Bug Finder

Developers can provide an error or describe unexpected behavior.

Example:

TypeError: Cannot read properties of undefined

CodeFrog can search the repository and identify the likely source.

Example:

Possible source:

userService.js

getUser() can return null, but the caller
directly accesses user.name.

Suggested fix:
Add null handling before accessing user.name.

The agent can then prepare a code change for review.

7. 🧪 AI Test Generator

CodeFrog can generate tests for existing functions and features.

For example:

Generate tests for createUser().

Possible test cases:

✓ Valid user
✓ Duplicate email
✓ Missing email
✓ Invalid password
✓ Unauthorized request
✓ Database error

The system can generate tests using frameworks such as:

Jest
Vitest
Other project-compatible testing frameworks

8. 🔎 AI Code Review

CodeFrog can analyze code changes and provide feedback.

Example:

Code Quality: 85/100
Security:      72/100
Performance:   90/100
Testing:       65/100

Possible findings:

⚠ Authorization check missing
⚠ Possible IDOR vulnerability
⚠ Database query can be optimized
⚠ Missing test coverage

Code review can be integrated into Pull Request workflows.

9. 👀 Code Diff Viewer

CodeFrog should never silently change a repository.

Before creating a Pull Request, the developer should be able to see exactly what the AI wants to change.

Example:

- router.get('/tasks', getTasks);

+ router.get(
+   '/tasks',
+   authenticateUser,
+   getTasks
+ );

Another example:

- router.delete('/tasks/:id', deleteTask);

+ router.delete(
+   '/tasks/:id',
+   authenticateUser,
+   authorizeAdmin,
+   deleteTask
+ );

The developer can review the proposed changes before approving them.

10. 🧪 Automated Test Execution

After generating changes, CodeFrog can run the project's tests.

Example:

Running tests...

✓ Authentication test
✓ Unauthorized request test
✓ Authorized request test
✓ Admin authorization test
✓ Existing task test

32 passed
0 failed

If tests fail, the agent can analyze the failures and propose another fix.

11. 🔐 Human-in-the-Loop Security

CodeFrog follows an important principle:

AI should not directly modify the production or main branch without human approval.

The intended workflow is:

AI
 ↓
Analyze
 ↓
Plan
 ↓
Generate Changes
 ↓
Show Diff
 ↓
Run Tests
 ↓
Security Scan
 ↓
👤 User Approval
 ↓
Create Branch
 ↓
Commit
 ↓
Create Pull Request

The developer remains responsible for approving the final changes.

12. 🌳 Automatic GitHub Workflow

After approval, CodeFrog can perform Git operations.

Example:

Branch

ai/fix-api-authentication

Commit

fix: secure unprotected API endpoints

Pull Request

AI Security Fixes

5 API endpoints were missing
authentication/authorization checks.

Files changed: 6

Tests: 32 passed

Security checks: Passed

The developer can then review and merge the Pull Request.

🧰 AI Agent Tools

The agent will use specialized tools to interact with the repository.

Planned tools include:

search_code()
read_file()
list_files()

analyze_routes()
analyze_dependencies()

generate_patch()

run_tests()
run_security_scan()

create_branch()
commit_changes()
create_pull_request()

The AI decides which tools are required for each task.

Example:

User:
"Find APIs without authentication."

        ↓

analyze_routes()

        ↓

read_file()

        ↓

analyze authentication middleware

        ↓

identify vulnerable endpoints

For a fix:

generate_patch()
        ↓
run_tests()
        ↓
run_security_scan()
        ↓
show_diff()
        ↓
user approval
        ↓
create_branch()
        ↓
commit_changes()
        ↓
create_pull_request()

💡 Example Agent Tasks

Security

Find IDOR vulnerabilities.

Find APIs without authentication.

Find hardcoded secrets.

Check insecure CORS configuration.

Bug Fixing

Find why login is failing.

Fix this TypeError.

Find APIs returning 500 errors.

Code Quality

Find duplicate code.

Refactor this controller.

Improve this database query.

Testing

Generate tests for authentication.

Find untested functions.

Documentation

Generate API documentation.

Update README according to the current project.

Performance

Find slow database queries.

Find unnecessary API calls.

🏗️ Architecture

                         ┌─────────────────────┐
                         │       Developer     │
                         └──────────┬──────────┘
                                    │
                                    ↓
                         ┌─────────────────────┐
                         │   CodeFrog Web App  │
                         └──────────┬──────────┘
                                    │
                                    ↓
                         ┌─────────────────────┐
                         │    CodeFrog API     │
                         └──────────┬──────────┘
                                    │
                                    ↓
                         ┌─────────────────────┐
                         │     AI Agent        │
                         └──────┬───────┬──────┘
                                │       │
                 ┌──────────────┘       └──────────────┐
                 ↓                                     ↓
        ┌─────────────────┐                   ┌─────────────────┐
        │ Repository Tools│                   │     LLM         │
        └────────┬────────┘                   └─────────────────┘
                 │
                 ↓
        ┌─────────────────┐
        │ GitHub API      │
        └────────┬────────┘
                 │
                 ↓
        ┌─────────────────┐
        │ GitHub Repository│
        └─────────────────┘

🧠 RAG Architecture

GitHub Repository
        │
        ↓
Repository Parser
        │
        ↓
Code Files
        │
        ↓
Chunking
        │
        ↓
Embeddings
        │
        ↓
Vector Database
        │
        ↓
Retriever
        │
        ↓
Relevant Code
        │
        ↓
LLM
        │
        ↓
Agent / Response

💻 Technology Stack

Frontend

React / Next.js
TypeScript
Tailwind CSS

Backend

Python
FastAPI
Uvicorn
Pydantic
SQLAlchemy

Database

PostgreSQL
Redis
pgvector

AI

LLM API
Embeddings
RAG
Vector Search
AI Agent / Tool Calling

GitHub Integration

GitHub OAuth
GitHub API
GitHub Webhooks
Git branches
Git commits
Pull Requests

DevOps

Docker
GitHub Actions
Cloud deployment

📁 Project Structure

The initial repository is planned as a monorepo:

codefrog/
│
├── frontend/
│   ├── components/
│   ├── pages/
│   ├── hooks/
│   ├── services/
│   └── ...
│
├── backend/
│   ├── controllers/
│   ├── routes/
│   ├── models/
│   ├── services/
│   ├── middleware/
│   └── ...
│
├── agent/
│   ├── tools/
│   ├── prompts/
│   ├── analyzers/
│   └── ...
│
├── README.md
├── .gitignore
└── docker-compose.yml

🖥️ Product Interface

The CodeFrog dashboard will provide access to:

Dashboard
Repositories
AI Agent
Code Review
Bug Finder
Test Generator
Security
Pull Requests
Settings

AI Agent interface

┌──────────────────────────────────────────────┐
│ 🐸 CodeFrog AI                               │
│                                              │
│ What should I work on?                       │
│                                              │
│ Find security vulnerabilities and fix them   │
│ without changing existing APIs.              │
│                                              │
│                         [ Run Agent → ]       │
└──────────────────────────────────────────────┘

🔄 Complete User Workflow

1. Create CodeFrog account
             ↓
2. Connect GitHub
             ↓
3. Select repository
             ↓
4. CodeFrog indexes repository
             ↓
5. Developer gives AI a task
             ↓
6. Agent analyzes repository
             ↓
7. Agent creates a plan
             ↓
8. Developer reviews plan
             ↓
9. Agent generates code changes
             ↓
10. Developer reviews diff
             ↓
11. Agent runs tests
             ↓
12. Agent runs security checks
             ↓
13. Developer approves
             ↓
14. Agent creates branch
             ↓
15. Agent commits changes
             ↓
16. Agent creates Pull Request
             ↓
17. Developer reviews PR
             ↓
18. Developer merges changes

🛡️ Security Principles

CodeFrog is designed with developer control and repository security in mind.

Core principles

Never expose GitHub access tokens to the frontend
Use OAuth for GitHub authentication
Use least-privilege GitHub permissions
Never automatically merge AI-generated Pull Requests
Require human approval before repository changes
Isolate code execution environments
Validate AI-generated patches
Run tests before creating Pull Requests
Run security checks on generated changes
Protect sensitive environment variables
Never expose repository secrets to the LLM unnecessarily

🚀 Development Roadmap

Phase 1 — Foundation

Phase 2 — GitHub Integration

Phase 3 — Codebase Intelligence

Phase 4 — AI Agent

Phase 5 — Code Modification

Phase 6 — GitHub Automation

Phase 7 — Advanced Features

🎯 Example

Developer:

Find all APIs that don't have authentication and fix them.

CodeFrog:

🔍 Analyzing repository...

Repository: talent-portal
Files analyzed: 247

Found 5 potentially unprotected endpoints:

1. GET /api/users
2. GET /api/tasks
3. POST /api/submissions
4. GET /api/reports
5. DELETE /api/tasks/:id

CodeFrog creates a plan:

AI PLAN

1. Add authentication middleware
2. Add authorization checks
3. Update affected routes
4. Update affected tests

Estimated files changed: 6

Developer:

[ Generate Changes ]

CodeFrog:

Changes Generated

6 files modified

[ View Diff ]

Developer:

[ Run Tests ]

CodeFrog:

✓ 32 tests passed
✓ Security checks passed

Developer:

[ Approve Changes ]

CodeFrog:

Branch:
ai/fix-api-authentication

Commit:
fix: secure unprotected API endpoints

Pull Request:
#128

This is the core CodeFrog experience.

🏆 What Makes CodeFrog Different?

CodeFrog is not designed to be another AI chatbot.

A traditional chatbot:

Developer
   ↓
Question
   ↓
AI
   ↓
Answer

CodeFrog:

Developer
   ↓
Task
   ↓
AI Agent
   ↓
Understand Repository
   ↓
Search Code
   ↓
Analyze
   ↓
Plan
   ↓
Generate Changes
   ↓
Run Tests
   ↓
Security Check
   ↓
Human Approval
   ↓
GitHub Branch
   ↓
Commit
   ↓
Pull Request

The goal

Understand → Analyze → Modify → Test → Review → Ship

📌 Project Status

🚧 Currently in development

CodeFrog AI is being developed as an AI + Full Stack engineering project focused on GitHub repository understanding and autonomous software development workflows.

🗺️ Future Vision

CodeFrog AI can eventually evolve into a complete AI engineering platform capable of helping developers with:

Repository maintenance
Security remediation
Bug fixing
Refactoring
Testing
Documentation
Performance optimization
Code review
Dependency upgrades
Pull Request automation
Continuous repository analysis

The long-term vision is simple:

Give CodeFrog a software engineering task and let it do the engineering work — while keeping the developer in control.

👨‍💻 Author

Shishir Mahato

Computer Science Engineering — Data Science

📄 License

License information will be added as the project develops.

🐸 CodeFrog AI

Jump into your codebase. Ship faster.

Local backend setup

The backend reads configuration from environment variables and a repository-root .env file. Never commit .env or place real credentials in .env.example.

Copy the safe template and replace every YOUR_... placeholder with local-only values:
```
Copy-Item .env.example .env
```
Start PostgreSQL. Docker Compose reads POSTGRES_USER, POSTGRES_PASSWORD, and POSTGRES_DB from .env:
```
docker compose up -d postgres
```

Run the API from the repository root:

uvicorn main:app --app-dir backend --reload

DATABASE_URL and AUTH_SECRET_KEY are required. Generate a unique local AUTH_SECRET_KEY of at least 32 characters; it signs short-lived local authentication tokens and must never be committed. APP_NAME, APP_ENV (development, test, or production), and LOG_LEVEL are optional. Use a PostgreSQL psycopg URL, such as postgresql+psycopg://USER:PASSWORD@localhost:5434/DATABASE (the Docker Compose database is published on host port 5434).

Local account passwords must be at least 12 characters. They are stored only as Argon2 hashes; registration and public-user responses never expose password hashes.

Connecting GitHub (web)

CodeFrog signs you in with GitHub OAuth, then lists your repositories so you can connect one.

1. Create a GitHub OAuth App (GitHub → Settings → Developer settings → OAuth Apps → New OAuth App):

Homepage URL: http://localhost:3000
Authorization callback URL: http://localhost:8000/api/v1/auth/github/callback

Use localhost everywhere for local development (frontend, backend, and the callback). Do not mix localhost and 127.0.0.1: the OAuth state cookie is bound to the host, and CORS allows only FRONTEND_URL.

2. Configure the backend in the repository-root .env (never commit it; the values below are placeholders):

DATABASE_URL=
AUTH_SECRET_KEY=
TOKEN_ENCRYPTION_KEY=
GITHUB_CLIENT_ID=
GITHUB_CLIENT_SECRET=
GITHUB_REDIRECT_URI=http://localhost:8000/api/v1/auth/github/callback
GITHUB_OAUTH_SCOPES=read:user user:email repo
FRONTEND_URL=http://localhost:3000

TOKEN_ENCRYPTION_KEY is a Fernet key (python -c "from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())"). It is required: the GitHub token is stored encrypted, and sign-in fails with a clear error if the key is missing or invalid instead of pretending to connect.
LLM_* and EMBEDDING_* are the server defaults for the AI provider. Each signed-in user can save their own LLM key/model and embedding key/model in Settings; those override the server defaults for that user, and anything a user has not set falls back to them. The two sides are independent (an LLM key is never used for embeddings, or the reverse; the same key may be entered on both). User keys are stored encrypted with TOKEN_ENCRYPTION_KEY, never returned by the API (only the last 4 characters are shown), and never logged. The key is not tested against the provider on save. Base URLs stay server-side (LLM_BASE_URL, EMBEDDING_BASE_URL). After changing the embedding model, re-scan your repositories to rebuild embeddings.
GITHUB_OAUTH_SCOPES defaults to read:user user:email repo. read:user and user:email (identity) are always requested even if you leave them out. repo is needed to list private repositories, clone, push, and open pull requests. Anyone who signed in before with narrower scopes must reconnect.
FRONTEND_URL is an origin (no path). It is where the OAuth callback sends the browser, and the only CORS origin.

3. Configure the frontend in frontend/.env.local:

NEXT_PUBLIC_API_URL=http://localhost:8000

4. Run both (uvicorn main:app --app-dir backend --reload and npm run dev in frontend/), open http://localhost:3000, and choose Connect GitHub (on the Repositories page or in Settings).

How the flow works

Connect GitHub is a full-page navigation to GET /api/v1/auth/github/login, which redirects to GitHub with a random, single-use state (CSRF protection, also bound to a cookie).
GitHub redirects to the backend callback, which checks the state, exchanges the code, links the account, and stores the GitHub token encrypted (it is never sent to the browser).
The backend redirects to FRONTEND_URL/auth/callback#access_token=<CodeFrog JWT>. The token is in the URL fragment (never a query string, so it is not sent to any server). On failure it redirects to #error=<code> with a fixed, safe code.
The frontend reads the fragment, removes it from the address bar immediately, keeps the JWT in sessionStorage (the only thing the app stores in the browser; never localStorage), and calls GET /api/v1/auth/me.
Repositories then shows your GitHub repositories (GET /api/v1/repositories/github). Choosing one calls POST /api/v1/repositories/connect, and the connected repository is shown with a Scan Repository button. Settings shows the connection state (✓ Connected, GitHub account: @you, Reconnect GitHub).

A 401 clears the session and returns you to Connect GitHub; a 403 offers Reconnect GitHub. Local (desktop) repositories are a separate flow and are not affected.

Run the backend tests with:

python -m pytest backend/tests -q

Frontend and desktop app

The UI lives in frontend/ (Next.js + React + TypeScript, Tailwind). The same UI runs in the browser and inside a Tauri desktop window that talks to the existing FastAPI backend.

Web UI

cd frontend
npm install
npm run dev        # http://localhost:3000
npm run lint
npm test           # unit tests for the UI state logic (Vitest)
npm run build      # regular web build

Desktop app (Tauri)

Prerequisites (one time): the Rust toolchain, the Tauri system prerequisites (on Windows: Visual Studio Build Tools with the "Desktop development with C++" workload, and WebView2).

cd frontend
npm install
npm run desktop:dev     # starts the Next.js dev server and opens the desktop window
npm run desktop:build   # static export (frontend/out) + installer under frontend/src-tauri/target

npm run build:desktop only produces the static export the desktop app loads (CODEFROG_DESKTOP=1); the normal npm run build is unchanged.

Local repository selection

In the desktop app, Open Repository opens the operating system's folder picker. The chosen folder is checked by a small Rust command (select_repository) that:

rejects paths that do not exist, are not folders, are unreadable, or contain no .git;
runs a few fixed, read-only git commands (no shell, nothing supplied by the UI) to read the current branch, whether the working tree has uncommitted changes, and the origin remote URL (with any embedded credentials removed).

The result is shown on the Repositories dashboard: name, local path, current branch, Git status, and remote URL. Errors are shown with fixed messages (INVALID_PATH, NOT_A_GIT_REPOSITORY, PERMISSION_DENIED, GIT_UNAVAILABLE), with a Try again action. The selected repository lives only in memory and is not remembered after the app closes.

Requirements: the desktop app (the native folder picker and the command do not exist in a browser, where Open Repository shows "Open Repository is available in the CodeFrog desktop app."), Git installed and on PATH, and the Rust toolchain plus Visual Studio C++ Build Tools (Windows) to build it.

Repository scanning, search, and the agent are later phases: selecting a repository only reads its name, path, branch, status, and remote.

Repository explorer

Once a repository is selected, the Repositories page shows a Files panel: an expandable file tree on the left and a read-only viewer on the right. Click a folder to open or close it, click a file to see its name, relative path, size, and text contents (whitespace and line breaks preserved). Refresh rebuilds the tree from disk and re-reads the open file. Nothing is written: the explorer never modifies the repository or creates commits.

Security boundary. The UI never sends a root or an absolute path. The desktop app remembers the repository that was selected with Open Repository and only serves files below it; the UI may ask only for a repository-relative path:

absolute paths, ../ traversal, backslashes, drive letters, :, empty or . segments, and control characters (including NUL) are rejected;
after the path is resolved on disk (symlinks followed), it must still be inside the repository, so a symlink pointing outside cannot be read; the tree never lists or follows symlinks;
ignored folders (below) cannot be opened even by typing their path, so .git (which can hold remote credentials) is never readable, including through a symlink;
file contents are not logged, stored, or sent anywhere: they are held in memory only while shown.

Ignored names (at any depth, case-insensitively): .git, node_modules, .next, dist, build, coverage, target, .venv, __pycache__.

Limits (constants in frontend/src-tauri/src/repository_files.rs):

Limit	Value	When exceeded
Directory depth	12 levels	deeper folders are shown empty and the tree is marked truncated
Entries (files + folders)	5,000	listing stops (deterministically) and the tree is marked truncated
File size	1 MB	the file is not opened

Files that are not UTF-8 text (binary files) are not displayed. The tree is sorted deterministically: folders first, then files, each alphabetically (case-insensitive).

Browser vs desktop. File browsing uses native commands, so it only works in the desktop app. In a browser, Open Repository shows "Open Repository is available in the CodeFrog desktop app." and no repository (and no files) can be selected; no fake data is shown.

Current desktop limitations

The explorer reads the tree and one file at a time on request. Nothing is scanned, indexed, searched, or sent anywhere, and it is not connected to the backend yet. There is no editor, no search, and no live file watching (use Refresh).
The Agent and Pull Requests pages are placeholders. Settings saves your own AI provider keys and models through /api/v1/settings/ai (keys are never persisted in the browser, never pre-filled, and cleared after saving).
The desktop shell's only native capabilities are the folder picker (dialog:allow-open) and four read-only commands (select_repository, list_repository_tree, read_repository_file, clear_selected_repository). There is no filesystem plugin, shell, or general Git access from the UI.
The Rust side (frontend/src-tauri) has not been compiled or run on every machine: it needs the Rust toolchain and, on Windows, the Visual Studio C++ Build Tools. Cargo.lock is created on the first desktop build; icons are generated placeholders.

Latest commit

History

Folders and files

Repository files navigation

🐸 CodeFrog AI

Your AI Software Engineer for GitHub

🚀 What is CodeFrog AI?

🎯 Vision

Core idea

🐸 Why "CodeFrog"?

Brand statement

⭐ Core Features

1. 🔗 GitHub Integration

Planned capabilities

2. 🤖 AI Developer Chat

3. 🧠 Codebase Understanding with RAG

Repository indexing flow

4. 🛠️ AI Software Engineer Agent

The Core Feature

5. 🔍 Security Analysis

6. 🐛 AI Bug Finder

7. 🧪 AI Test Generator

8. 🔎 AI Code Review

9. 👀 Code Diff Viewer

10. 🧪 Automated Test Execution

11. 🔐 Human-in-the-Loop Security

12. 🌳 Automatic GitHub Workflow

Branch

Commit

Pull Request

🧰 AI Agent Tools

💡 Example Agent Tasks

Security

Bug Fixing

Code Quality

Testing

Documentation

Performance

🏗️ Architecture

🧠 RAG Architecture

💻 Technology Stack

Frontend

Backend

Database

AI

GitHub Integration

DevOps

📁 Project Structure

🖥️ Product Interface

AI Agent interface

🔄 Complete User Workflow

🛡️ Security Principles

Core principles

🚀 Development Roadmap

Phase 1 — Foundation

Phase 2 — GitHub Integration

Phase 3 — Codebase Intelligence

Phase 4 — AI Agent

Phase 5 — Code Modification

Phase 6 — GitHub Automation

Phase 7 — Advanced Features

🎯 Example

🏆 What Makes CodeFrog Different?

The goal

📌 Project Status

🗺️ Future Vision

👨‍💻 Author

📄 License

🐸 CodeFrog AI

Local backend setup

Connecting GitHub (web)

Frontend and desktop app

Web UI

Desktop app (Tauri)

Local repository selection

Repository explorer

Current desktop limitations

About

Resources

Stars