feat: adds support to create and edit files. Moves publish to be independent of files. Adds discard option

.gitignore

···
 Thumbs.db
 .Spotlight-V100
 .Trashes
+
+# AI
+IMPLEMENTATION_PLAN.md

IMPLEMENTATION_PLAN.md

···
-# MarkEdit - Implementation Plan
-
-## Project Overview
-
-MarkEdit is a markdown editor designed for managing blog posts stored in various locations (initially GitHub, later Google Drive, Dropbox, etc.). It provides a WYSIWYG editing experience using TipTap, with git-based version control for GitHub repositories.
-
-### Core Features (MVP)
-- GitHub OAuth authentication
-- Repository and file browsing
-- Markdown editing with TipTap
-- Automatic branch management
-- Commit and Pull Request creation
-- Docker-based deployment
-
-### Explicitly Out of Scope (MVP)
-- Image uploads (links only)
-- Search functionality
-- Version history UI
-- Collaborative editing
-- Merge conflict resolution (create new branch instead)
-- Preview mode
-- Keyboard shortcuts
-- SSR (Astro runs in client-only mode)
-
-## Technical Stack
-
-### Backend
-- **Language**: Go 1.21+
-- **Router**: `chi` (lightweight, composable)
-- **OAuth**: `goth` (multi-provider support)
-- **Git Operations**: `go-git` (native Go git implementation)
-- **Database**: SQLite with `modernc.org/sqlite` (pure Go, no CGO)
-- **Configuration**: `viper`
-- **Sessions**: `gorilla/sessions` with encrypted cookies
-
-### Frontend
-- **Framework**: Astro (client-only, no SSR)
-- **UI Library**: React 18
-- **UI Components**: shadcn/ui (with Tailwind CSS)
-- **Editor**: TipTap (React)
-- **Styling**: Tailwind CSS
-- **State Management**: `@tanstack/react-query` for server state
-- **HTTP Client**: `axios` or `fetch`
-- **Build**: Vite (via Astro)
-
-### Deployment
-- **Container**: Docker (multi-stage build)
-- **Base Image**: `alpine` or `scratch` for Go binary
-- **Size Target**: < 50MB
-
-## Architecture
-
-### High-Level Overview
-
-```
-┌─────────────────┐
-│  Astro Frontend │ (Static React App)
-│  (Port 3000)    │
-└────────┬────────┘
-         │ HTTP/REST
-         ▼
-┌─────────────────┐
-│   Go Backend    │ (Single Binary)
-│   (Port 8080)   │
-└────────┬────────┘
-         │
-    ┌────┴────┬──────────┬──────────┐
-    ▼         ▼          ▼          ▼
-  SQLite   GitHub    go-git    Sessions
-```
-
-### Component Responsibilities
-
-**Backend (Go):**
-- OAuth flow handling
-- GitHub API interactions
-- Local git operations (clone, branch, commit, push)
-- Branch lifecycle management
-- File CRUD operations
-- Session management
-
-**Frontend (Astro/React):**
-- User interface
-- TipTap editor integration
-- File tree rendering
-- API client
-- Local state management
-
-### Connector Architecture
-
-Future-proof design for multiple storage backends:
-
-```go
-// pkg/connectors/connector.go
-type Connector interface {
-    // Authentication
-    Authenticate(ctx context.Context, token string) error
-
-    // Repository/Storage listing
-    ListRepositories(ctx context.Context) ([]Repository, error)
-
-    // File operations
-    ListFiles(ctx context.Context, repoID, path string) ([]FileNode, error)
-    ReadFile(ctx context.Context, repoID, path string) (*FileContent, error)
-    WriteFile(ctx context.Context, repoID, path string, content []byte) error
-
-    // Version control (optional)
-    CreateBranch(ctx context.Context, repoID, branchName string) error
-    CommitChanges(ctx context.Context, repoID, branch, message string, files []string) error
-    PushBranch(ctx context.Context, repoID, branch string) error
-    CreatePullRequest(ctx context.Context, repoID, branch, title, description string) (*PullRequest, error)
-
-    // Capabilities
-    SupportsVersionControl() bool
-    GetType() string // "github", "gdrive", "dropbox"
-}
-
-// Implementations
-type GitHubConnector struct { ... }
-// Later: GoogleDriveConnector, DropboxConnector
-```
-
-## Database Schema
-
-### SQLite Tables
-
-```sql
--- Users table (future: when email auth is added)
-CREATE TABLE users (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    github_id INTEGER UNIQUE,
-    username TEXT NOT NULL,
-    email TEXT,
-    avatar_url TEXT,
-    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
-);
-
--- Sessions/Tokens (encrypted access tokens)
-CREATE TABLE auth_tokens (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    user_id INTEGER NOT NULL,
-    provider TEXT NOT NULL, -- "github", "gdrive", etc.
-    access_token TEXT NOT NULL, -- encrypted
-    refresh_token TEXT, -- encrypted
-    expires_at DATETIME,
-    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
-);
-
--- Branch state tracking
-CREATE TABLE branch_states (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    user_id INTEGER NOT NULL,
-    repo_full_name TEXT NOT NULL, -- "owner/repo"
-    branch_name TEXT NOT NULL,
-    base_branch TEXT DEFAULT 'main', -- PR target
-    last_push_at DATETIME NOT NULL,
-    has_uncommitted_changes BOOLEAN DEFAULT FALSE,
-    file_paths TEXT, -- JSON array of edited files
-    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-    UNIQUE(user_id, repo_full_name),
-    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
-);
-
--- Work-in-progress content (auto-save buffer)
-CREATE TABLE draft_content (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    user_id INTEGER NOT NULL,
-    repo_full_name TEXT NOT NULL,
-    file_path TEXT NOT NULL,
-    content TEXT NOT NULL,
-    last_saved_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-    UNIQUE(user_id, repo_full_name, file_path),
-    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
-);
-
--- Indexes
-CREATE INDEX idx_auth_tokens_user_provider ON auth_tokens(user_id, provider);
-CREATE INDEX idx_branch_states_user_repo ON branch_states(user_id, repo_full_name);
-CREATE INDEX idx_draft_content_user_repo_file ON draft_content(user_id, repo_full_name, file_path);
-```
-
-## API Specification
-
-### Authentication Endpoints
-
-#### `POST /api/auth/github/login`
-Start GitHub OAuth flow.
-
-**Response:**
-```json
-{
-  "auth_url": "https://github.com/login/oauth/authorize?client_id=..."
-}
-```
-
-#### `GET /api/auth/github/callback`
-OAuth callback handler (redirects to frontend).
-
-**Query Params:**
-- `code`: OAuth authorization code
-- `state`: CSRF token
-
-**Redirects to:** `http://localhost:3000/dashboard?token={session_token}`
-
-#### `GET /api/auth/user`
-Get current authenticated user.
-
-**Headers:**
-- `Cookie: session=...`
-
-**Response:**
-```json
-{
-  "id": 1,
-  "username": "johndoe",
-  "avatar_url": "https://avatars.githubusercontent.com/...",
-  "provider": "github"
-}
-```
-
-#### `POST /api/auth/logout`
-Logout and clear session.
-
-**Response:**
-```json
-{
-  "success": true
-}
-```
-
-### Repository Endpoints
-
-#### `GET /api/repos`
-List user's repositories.
-
-**Query Params:**
-- `type`: `owner` | `collaborator` | `all` (default: `owner`)
-- `sort`: `updated` | `created` | `name` (default: `updated`)
-
-**Response:**
-```json
-{
-  "repositories": [
-    {
-      "id": 12345,
-      "full_name": "johndoe/blog",
-      "name": "blog",
-      "owner": "johndoe",
-      "private": false,
-      "default_branch": "main",
-      "updated_at": "2026-01-19T10:30:00Z"
-    }
-  ]
-}
-```
-
-#### `GET /api/repos/:owner/:repo/files`
-List files in repository (recursive).
-
-**Query Params:**
-- `path`: Directory path (default: root)
-- `branch`: Branch name (default: default_branch)
-- `extensions`: Comma-separated list (e.g., `md,mdx`)
-
-**Response:**
-```json
-{
-  "files": [
-    {
-      "path": "posts/hello-world.md",
-      "name": "hello-world.md",
-      "type": "file",
-      "size": 1234,
-      "sha": "abc123..."
-    },
-    {
-      "path": "posts/drafts",
-      "name": "drafts",
-      "type": "dir",
-      "children": [...]
-    }
-  ],
-  "current_branch": "main"
-}
-```
-
-#### `GET /api/repos/:owner/:repo/files/*path`
-Get file content.
-
-**Query Params:**
-- `branch`: Branch name (optional, defaults to default_branch)
-
-**Response:**
-```json
-{
-  "content": "# Hello World\n\nThis is my post...",
-  "frontmatter": {
-    "title": "Hello World",
-    "date": "2026-01-19",
-    "tags": ["intro", "blog"]
-  },
-  "path": "posts/hello-world.md",
-  "sha": "abc123...",
-  "branch": "main"
-}
-```
-
-#### `PUT /api/repos/:owner/:repo/files/*path`
-Update file content (doesn't commit immediately, saves to draft).
-
-**Request Body:**
-```json
-{
-  "content": "# Updated content...",
-  "frontmatter": {
-    "title": "Updated Title",
-    "date": "2026-01-19"
-  }
-}
-```
-
-**Response:**
-```json
-{
-  "success": true,
-  "draft_saved": true
-}
-```
-
-### Branch & Publishing Endpoints
-
-#### `GET /api/repos/:owner/:repo/branch/status`
-Get current branch state for this repo.
-
-**Response:**
-```json
-{
-  "branch_name": "markedit-1705659600",
-  "base_branch": "main",
-  "has_changes": true,
-  "last_push_at": "2026-01-19T09:30:00Z",
-  "edited_files": ["posts/hello-world.md"],
-  "hours_since_push": 1.5
-}
-```
-
-#### `POST /api/repos/:owner/:repo/publish`
-Commit changes and create PR.
-
-**Request Body:**
-```json
-{
-  "commit_message": "Update blog posts",
-  "pr_title": "Blog updates from MarkEdit",
-  "pr_description": "Updated the following files:\n- posts/hello-world.md",
-  "files": ["posts/hello-world.md"] // optional, defaults to all changed files
-}
-```
-
-**Response:**
-```json
-{
-  "success": true,
-  "branch": "markedit-1705659600",
-  "commit_sha": "def456...",
-  "pull_request": {
-    "number": 42,
-    "url": "https://github.com/johndoe/blog/pull/42",
-    "html_url": "https://github.com/johndoe/blog/pull/42"
-  }
-}
-```
-
-### Health & Info
-
-#### `GET /api/health`
-Health check endpoint.
-
-**Response:**
-```json
-{
-  "status": "ok",
-  "version": "0.1.0"
-}
-```
-
-## Frontend Structure
-
-### File Organization
-
-```
-frontend/
-├── src/
-│   ├── components/
-│   │   ├── editor/
-│   │   │   ├── TipTapEditor.tsx       # Main editor component
-│   │   │   ├── MenuBar.tsx            # Editor toolbar
-│   │   │   ├── FrontmatterEditor.tsx  # Frontmatter form
-│   │   │   └── extensions/            # Custom TipTap extensions
-│   │   ├── files/
-│   │   │   ├── FileTree.tsx           # Recursive file tree
-│   │   │   ├── FileNode.tsx           # Single file/folder node
-│   │   │   └── RepoSelector.tsx       # Dropdown for repo selection
-│   │   ├── layout/
-│   │   │   ├── Header.tsx
-│   │   │   ├── Sidebar.tsx
-│   │   │   └── Layout.tsx
-│   │   └── ui/                    # shadcn/ui components
-│   │       ├── button.tsx
-│   │       ├── dialog.tsx
-│   │       ├── dropdown-menu.tsx
-│   │       ├── input.tsx
-│   │       ├── label.tsx
-│   │       ├── separator.tsx
-│   │       ├── spinner.tsx
-│   │       └── ... (other shadcn/ui components)
-│   ├── lib/
-│   │   ├── api/
-│   │   │   ├── client.ts              # Axios instance with interceptors
-│   │   │   ├── repos.ts               # Repository API calls
-│   │   │   ├── files.ts               # File API calls
-│   │   │   └── auth.ts                # Auth API calls
-│   │   ├── utils/
-│   │   │   ├── cn.ts                  # Tailwind class merging utility (shadcn)
-│   │   │   ├── markdown.ts            # Markdown/frontmatter parsing
-│   │   │   ├── debounce.ts
-│   │   │   └── formatters.ts
-│   │   └── types/
-│   │       ├── api.ts                 # API response types
-│   │       └── editor.ts              # Editor-specific types
-│   ├── pages/
-│   │   ├── index.astro                # Landing/login page
-│   │   ├── dashboard.astro            # Main app (mounts React)
-│   │   └── callback.astro             # OAuth callback handler
-│   ├── stores/
-│   │   ├── authStore.ts               # Zustand or Context for auth
-│   │   └── editorStore.ts             # Editor state
-│   └── styles/
-│       └── global.css                 # Tailwind imports
-├── public/
-│   └── favicon.svg
-├── astro.config.mjs
-├── tailwind.config.mjs
-├── components.json                     # shadcn/ui configuration
-├── tsconfig.json
-└── package.json
-```
-
-### Key Components
-
-#### TipTapEditor.tsx
-```typescript
-interface TipTapEditorProps {
-  initialContent: string;
-  initialFrontmatter: Record<string, any>;
-  onSave: (content: string, frontmatter: Record<string, any>) => void;
-  autoSave?: boolean;
-  autoSaveInterval?: number; // milliseconds
-}
-```
-
-#### FileTree.tsx
-```typescript
-interface FileTreeProps {
-  files: FileNode[];
-  selectedFile: string | null;
-  onFileSelect: (path: string) => void;
-  loading?: boolean;
-}
-```
-
-### Pages
-
-#### `dashboard.astro`
-Main application shell. Mounts React app client-side.
-
-```astro
----
-// No SSR, all client-side
----
-<html>
-  <head>
-    <title>MarkEdit</title>
-  </head>
-  <body>
-    <div id="app"></div>
-    <script>
-      import App from '../components/App.tsx';
-      import { createRoot } from 'react-dom/client';
-
-      const root = createRoot(document.getElementById('app'));
-      root.render(<App />);
-    </script>
-  </body>
-</html>
-```
-
-### State Management
-
-Use React Query for server state:
-
-```typescript
-// hooks/useRepositories.ts
-export function useRepositories() {
-  return useQuery({
-    queryKey: ['repositories'],
-    queryFn: () => api.repos.list()
-  });
-}
-
-// hooks/useFileContent.ts
-export function useFileContent(owner: string, repo: string, path: string) {
-  return useQuery({
-    queryKey: ['file', owner, repo, path],
-    queryFn: () => api.files.get(owner, repo, path),
-    enabled: !!path
-  });
-}
-
-// hooks/useUpdateFile.ts
-export function useUpdateFile() {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: (params) => api.files.update(params),
-    onSuccess: () => {
-      queryClient.invalidateQueries(['file']);
-    }
-  });
-}
-```
-
-## Branch Management Logic
-
-### Branch Lifecycle
-
-```
-┌─────────────────┐
-│  Start Session  │
-└────────┬────────┘
-         │
-         ▼
-   Check DB for
-  existing branch
-         │
-    ┌────┴────┐
-    │         │
-  Found    Not Found
-    │         │
-    ▼         ▼
-Check gap   Create new
-> 4 hours?  branch
-    │
-┌───┴───┐
-│       │
-Yes    No
-│       │
-▼       ▼
-Delete  Reuse
-Create  branch
-new
-│       │
-└───┬───┘
-    │
-    ▼
-┌─────────────────┐
-│  User edits     │
-│  files          │
-└────────┬────────┘
-         │
-         ▼
-   Auto-save to
-   draft table
-         │
-         ▼
-   User clicks
-   "Publish"
-         │
-         ▼
-┌─────────────────┐
-│ Commit & Push   │
-│ Create PR       │
-│ Update DB       │
-└────────┬────────┘
-         │
-         ▼
-┌─────────────────┐
-│ Branch stays    │
-│ active for      │
-│ 4 hours         │
-└─────────────────┘
-```
-
-### Implementation (Go)
-
-```go
-// internal/git/branch_manager.go
-
-type BranchManager struct {
-    db  *sql.DB
-    git GitOperations
-}
-
-func (bm *BranchManager) GetOrCreateBranch(ctx context.Context, userID int, repoFullName string) (string, error) {
-    // 1. Check database for existing branch
-    state, err := bm.getBranchState(ctx, userID, repoFullName)
-    if err != nil && err != sql.ErrNoRows {
-        return "", err
-    }
-
-    // 2. No existing branch
-    if state == nil {
-        return bm.createNewBranch(ctx, userID, repoFullName)
-    }
-
-    // 3. Check time gap
-    hoursSincePush := time.Since(state.LastPushAt).Hours()
-
-    // 4. Gap > 4 hours and no uncommitted changes
-    if hoursSincePush > 4 && !state.HasUncommittedChanges {
-        // Delete old branch locally (not on remote)
-        _ = bm.git.DeleteLocalBranch(repoFullName, state.BranchName)
-        return bm.createNewBranch(ctx, userID, repoFullName)
-    }
-
-    // 5. Reuse existing branch
-    return state.BranchName, nil
-}
-
-func (bm *BranchManager) createNewBranch(ctx context.Context, userID int, repoFullName string) (string, error) {
-    branchName := fmt.Sprintf("markedit-%d", time.Now().Unix())
-
-    // Create branch in git
-    if err := bm.git.CreateBranch(repoFullName, branchName); err != nil {
-        return "", err
-    }
-
-    // Save to database
-    if err := bm.saveBranchState(ctx, userID, repoFullName, branchName); err != nil {
-        return "", err
-    }
-
-    return branchName, nil
-}
-
-func (bm *BranchManager) HandleConflict(ctx context.Context, userID int, repoFullName string) (string, error) {
-    // Get current branch
-    state, _ := bm.getBranchState(ctx, userID, repoFullName)
-
-    // Delete old branch locally
-    if state != nil {
-        _ = bm.git.DeleteLocalBranch(repoFullName, state.BranchName)
-    }
-
-    // Create new branch
-    return bm.createNewBranch(ctx, userID, repoFullName)
-}
-```
-
-## Implementation Phases
-
-### Phase 1: Foundation (Week 1-2) ✅
-**Goal:** Basic authentication and file browsing
-
-**Backend Tasks:**
-- [x] Project setup (Go modules, directory structure)
-- [x] SQLite database setup with migrations
-- [x] GitHub OAuth integration with goth
-- [x] Session management with encrypted cookies
-- [x] Basic HTTP server with chi
-- [x] Health check endpoint
-- [x] GET /api/auth/github/login
-- [x] GET /api/auth/github/callback
-- [x] GET /api/auth/user
-- [x] GET /api/repos (list repositories)
-- [x] GET /api/repos/:owner/:repo/files (list files)
-
-**Frontend Tasks:**
-- [x] Astro project setup
-- [x] Tailwind CSS configuration
-- [x] shadcn/ui setup and initial components (button, dialog, input, etc.)
-- [x] Landing page with "Login with GitHub" button
-- [x] OAuth callback handler
-- [x] Dashboard shell (empty)
-- [x] Repository selector dropdown
-- [x] File tree component (read-only)
-- [x] API client setup (axios with interceptors)
-
-**Testing:**
-- [x] Manual: Complete OAuth flow
-- [x] Manual: View list of repositories
-- [x] Manual: Browse files in a test repository
-
-**Deliverable:** User can log in and browse their repositories and files.
-
----
-
-### Phase 2: Editor Integration (Week 3-4) ✅
-**Goal:** Read and edit markdown files
-
-**Backend Tasks:**
-- [x] GET /api/repos/:owner/:repo/files/*path (get file content)
-- [x] Markdown + YAML frontmatter parser
-- [x] PUT /api/repos/:owner/:repo/files/*path (save to draft)
-- [x] Draft content storage in SQLite
-
-**Frontend Tasks:**
-- [x] TipTap editor setup
-- [x] Markdown extensions for TipTap
-- [x] Frontmatter editor component (form)
-- [x] File selection handler
-- [x] Content display/edit toggle
-- [x] Auto-save functionality (debounced)
-- [x] Unsaved changes warning
-
-**Testing:**
-- [x] Manual: Open a markdown file
-- [x] Manual: Edit content and see auto-save
-- [x] Manual: Switch files and verify draft persistence
-
-**Deliverable:** User can read and edit markdown files with auto-save.
-
----
-
-### Phase 3: Git Operations (Week 5-6) ✅
-**Goal:** Branch management and publishing
-
-**Backend Tasks:**
-- [x] go-git integration
-- [x] Repository cloning/caching logic
-- [x] Branch manager implementation
-- [x] GET /api/repos/:owner/:repo/branch/status
-- [x] POST /api/repos/:owner/:repo/publish
-- [x] Commit creation
-- [x] Push to remote
-- [x] Pull request creation via GitHub API
-- [x] Branch state tracking in SQLite
-
-**Frontend Tasks:**
-- [x] Branch status display in UI
-- [x] "Publish" button with confirmation modal
-- [x] Commit message input
-- [x] PR title/description inputs
-- [x] Success notification with PR link
-- [x] Error handling for conflicts
-
-**Testing:**
-- [x] Manual: Edit file, publish, verify PR created
-- [ ] Manual: Edit multiple files, verify single PR
-- [ ] Manual: Test branch reuse within 4-hour window
-- [ ] Manual: Test new branch creation after 4 hours
-- [ ] Manual: Simulate conflict, verify new branch
-
-**Deliverable:** User can publish changes via Pull Requests.
-
----
-
-### Phase 4: Polish & Deployment (Week 7-8)
-**Goal:** Production-ready Docker deployment
-
-**Tasks:**
-- [ ] Multi-stage Dockerfile
-- [ ] Docker Compose setup
-- [ ] Environment variable configuration
-- [ ] Build scripts
-- [ ] Error handling improvements
-- [ ] Loading states
-- [ ] Empty states (no repos, no files)
-- [ ] Responsive design testing
-- [ ] Security audit (token encryption, CORS, CSRF)
-- [ ] Basic documentation (README, SETUP.md)
-- [ ] GitHub Actions for builds (optional)
-
-**Testing:**
-- [ ] Manual: Full end-to-end workflow
-- [ ] Manual: Docker build and run
-- [ ] Manual: Test on different screen sizes
-- [ ] Security: Review auth flow, token storage
-
-**Deliverable:** Docker image ready for self-hosting.
-
----
-
-### Phase 5: MVP Refinements (Week 9-10)
-**Goal:** UX improvements and bug fixes
-
-**Tasks:**
-- [ ] User feedback collection
-- [ ] Bug fixes from testing
-- [ ] Performance optimization (large repos)
-- [ ] Better error messages
-- [ ] Loading indicators
-- [ ] Accessibility improvements (keyboard nav, ARIA)
-- [ ] Dark mode support (optional)
-- [ ] GitHub Actions for CI/CD
-- [ ] Deployment guide for common platforms
-
-**Deliverable:** Stable MVP ready for open source release.
-
-## Configuration
-
-### Environment Variables
-
-```bash
-# Backend (Go)
-# Server
-PORT=8080
-FRONTEND_URL=http://localhost:3000
-ALLOWED_ORIGINS=http://localhost:3000
-
-# GitHub OAuth
-GITHUB_CLIENT_ID=your_github_client_id
-GITHUB_CLIENT_SECRET=your_github_client_secret
-GITHUB_REDIRECT_URL=http://localhost:8080/api/auth/github/callback
-
-# Session
-SESSION_SECRET=your-random-session-secret-min-32-chars
-SESSION_SECURE=false  # true in production (HTTPS only)
-SESSION_MAX_AGE=86400 # 24 hours
-
-# Database
-DATABASE_PATH=./data/markedit.db
-
-# Git
-GIT_CACHE_DIR=./data/repos
-GIT_AUTHOR_NAME=MarkEdit
-GIT_AUTHOR_EMAIL=[e-mail]
-
-# Logging
-LOG_LEVEL=info # debug, info, warn, error
-```
-
-### Development vs Production
-
-**Development:**
-```bash
-# .env.development
-FRONTEND_URL=http://localhost:3000
-SESSION_SECURE=false
-LOG_LEVEL=debug
-```
-
-**Production:**
-```bash
-# .env.production
-FRONTEND_URL=https://markedit.example.com
-SESSION_SECURE=true
-LOG_LEVEL=info
-ALLOWED_ORIGINS=https://markedit.example.com
-```
-
-## File Structure (Complete)
-
-```
-markedit/
-├── backend/
-│   ├── cmd/
-│   │   └── server/
-│   │       └── main.go                 # Entry point
-│   ├── internal/
-│   │   ├── api/
-│   │   │   ├── handlers/
-│   │   │   │   ├── auth.go            # Auth handlers
-│   │   │   │   ├── repos.go           # Repository handlers
-│   │   │   │   ├── files.go           # File handlers
-│   │   │   │   └── branch.go          # Branch/publish handlers
-│   │   │   ├── middleware/
-│   │   │   │   ├── auth.go            # Auth middleware
-│   │   │   │   ├── cors.go            # CORS middleware
-│   │   │   │   └── logger.go          # Logging middleware
-│   │   │   └── router.go              # Route setup
-│   │   ├── auth/
-│   │   │   ├── github.go              # GitHub OAuth setup
-│   │   │   └── session.go             # Session management
-│   │   ├── connectors/
-│   │   │   ├── connector.go           # Interface definition
-│   │   │   ├── github.go              # GitHub implementation
-│   │   │   └── factory.go             # Connector factory
-│   │   ├── git/
-│   │   │   ├── operations.go          # Git operations (clone, commit, push)
-│   │   │   ├── branch_manager.go      # Branch lifecycle logic
-│   │   │   └── cache.go               # Repository caching
-│   │   ├── database/
-│   │   │   ├── db.go                  # Database connection
-│   │   │   ├── migrations/
-│   │   │   │   └── 001_initial.sql
-│   │   │   ├── queries/
-│   │   │   │   ├── users.sql
-│   │   │   │   ├── auth_tokens.sql
-│   │   │   │   ├── branch_states.sql
-│   │   │   │   └── draft_content.sql
-│   │   │   └── models.go              # Data models
-│   │   ├── markdown/
-│   │   │   ├── parser.go              # Frontmatter parser
-│   │   │   └── serializer.go          # Frontmatter serializer
-│   │   └── config/
-│   │       └── config.go              # Configuration loading
-│   ├── pkg/
-│   │   └── types/
-│   │       ├── api.go                 # API types
-│   │       └── errors.go              # Custom errors
-│   ├── migrations/
-│   │   └── 001_initial.sql
-│   ├── go.mod
-│   ├── go.sum
-│   └── Makefile
-├── frontend/
-│   ├── src/
-│   │   ├── components/
-│   │   │   ├── editor/
-│   │   │   │   ├── TipTapEditor.tsx
-│   │   │   │   ├── MenuBar.tsx
-│   │   │   │   ├── FrontmatterEditor.tsx
-│   │   │   │   └── extensions/
-│   │   │   │       ├── markdown.ts
-│   │   │   │       └── codeBlock.ts
-│   │   │   ├── files/
-│   │   │   │   ├── FileTree.tsx
-│   │   │   │   ├── FileNode.tsx
-│   │   │   │   └── RepoSelector.tsx
-│   │   │   ├── layout/
-│   │   │   │   ├── Header.tsx
-│   │   │   │   ├── Sidebar.tsx
-│   │   │   │   └── Layout.tsx
-│   │   │   ├── ui/                    # shadcn/ui components
-│   │   │   │   ├── button.tsx
-│   │   │   │   ├── dialog.tsx
-│   │   │   │   ├── dropdown-menu.tsx
-│   │   │   │   ├── input.tsx
-│   │   │   │   ├── label.tsx
-│   │   │   │   ├── separator.tsx
-│   │   │   │   └── ... (other shadcn/ui components)
-│   │   │   └── App.tsx                # Main React app
-│   │   ├── lib/
-│   │   │   ├── api/
-│   │   │   │   ├── client.ts
-│   │   │   │   ├── auth.ts
-│   │   │   │   ├── repos.ts
-│   │   │   │   └── files.ts
-│   │   │   ├── hooks/
-│   │   │   │   ├── useAuth.ts
-│   │   │   │   ├── useRepositories.ts
-│   │   │   │   ├── useFiles.ts
-│   │   │   │   └── useFileContent.ts
-│   │   │   ├── utils/
-│   │   │   │   ├── cn.ts              # Tailwind class merging utility
-│   │   │   │   ├── markdown.ts
-│   │   │   │   ├── debounce.ts
-│   │   │   │   └── formatters.ts
-│   │   │   └── types/
-│   │   │       ├── api.ts
-│   │   │       └── editor.ts
-│   │   ├── stores/
-│   │   │   └── authStore.ts
-│   │   ├── pages/
-│   │   │   ├── index.astro
-│   │   │   ├── dashboard.astro
-│   │   │   └── callback.astro
-│   │   └── styles/
-│   │       └── global.css
-│   ├── public/
-│   │   └── favicon.svg
-│   ├── astro.config.mjs
-│   ├── tailwind.config.mjs
-│   ├── components.json                 # shadcn/ui configuration
-│   ├── tsconfig.json
-│   └── package.json
-├── docker/
-│   ├── Dockerfile                      # Multi-stage build
-│   └── docker-compose.yml
-├── .github/
-│   └── workflows/
-│       ├── build.yml                   # CI build
-│       └── release.yml                 # Release automation
-├── docs/
-│   ├── SETUP.md                        # Setup instructions
-│   ├── DEPLOYMENT.md                   # Deployment guide
-│   └── ARCHITECTURE.md                 # Architecture details
-├── .env.example
-├── .gitignore
-├── README.md
-├── LICENSE
-└── IMPLEMENTATION_PLAN.md              # This file
-```
-
-## Development Workflow
-
-### Initial Setup
-
-```bash
-# Clone repository
-git clone https://github.com/yourusername/markedit.git
-cd markedit
-
-# Backend setup
-cd backend
-cp ../.env.example .env
-# Edit .env with your GitHub OAuth credentials
-go mod download
-make migrate-up
-make run
-
-# Frontend setup (new terminal)
-cd frontend
-bun install
-# Initialize shadcn/ui (if not already done)
-bunx shadcn-ui@latest init
-bun run dev
-
-# Visit http://localhost:3000
-```
-
-### Docker Development
-
-```bash
-# Build and run
-docker-compose up --build
-
-# Visit http://localhost:3000
-```
-
-### GitHub OAuth Setup
-
-1. Go to https://github.com/settings/developers
-2. Create new OAuth App
-3. Set Authorization callback URL: `http://localhost:8080/api/auth/github/callback`
-4. Copy Client ID and Client Secret to `.env`
-
-## Testing Strategy
-
-### Manual Testing Checklist (MVP)
-
-**Authentication:**
-- [ ] Login with GitHub redirects correctly
-- [ ] Callback handles OAuth code
-- [ ] Session persists across page refreshes
-- [ ] Logout clears session
-- [ ] Unauthorized requests redirect to login
-
-**Repository Browsing:**
-- [ ] List displays all user repositories
-- [ ] Repository selection loads file tree
-- [ ] File tree shows directories and markdown files
-- [ ] File tree filters non-markdown files
-
-**File Editing:**
-- [ ] Selecting file loads content in editor
-- [ ] Frontmatter displays in separate form
-- [ ] Editor shows markdown content
-- [ ] Auto-save triggers after edits
-- [ ] Switching files saves current file
-- [ ] Browser refresh preserves unsaved changes
-
-**Publishing:**
-- [ ] Branch status shows correct information
-- [ ] Publish button enables when changes exist
-- [ ] Commit message is required
-- [ ] PR creation succeeds
-- [ ] PR link is displayed
-- [ ] Branch reuse works within 4 hours
-- [ ] New branch created after 4-hour gap
-- [ ] Conflict creates new branch
-
-**Error Handling:**
-- [ ] Network errors show user-friendly messages
-- [ ] API errors are logged and displayed
-- [ ] 401 errors redirect to login
-- [ ] Invalid file paths show error
-
-### Future Testing (Post-MVP)
-
-- Unit tests for Go backend (testify)
-- Integration tests for API endpoints
-- E2E tests with Playwright
-- Performance testing with large repositories
-
-## Security Considerations
-
-### Current Implementation
-
-1. **OAuth Token Storage:**
-   - Encrypted in SQLite using AES-256
-   - Never exposed to frontend
-   - Backend proxies all GitHub API calls
-
-2. **Session Management:**
-   - HTTP-only cookies
-   - Secure flag in production (HTTPS)
-   - CSRF protection via SameSite=Lax
-   - Encrypted session data
-
-3. **CORS:**
-   - Whitelist specific origins
-   - Credentials included in requests
-
-4. **Input Validation:**
-   - Sanitize file paths
-   - Validate repository ownership
-   - Limit file sizes
-
-### Future Enhancements
-
-- Rate limiting
-- Content Security Policy (CSP)
-- Subresource Integrity (SRI)
-- Audit logging
-- RBAC when multi-user support is added
-
-## Performance Considerations
-
-### Backend
-
-- **Repository Caching:** Clone repos to local disk, pull for updates
-- **Database Indexes:** On user_id, repo_full_name, file_path
-- **Connection Pooling:** SQLite with WAL mode
-- **Compression:** gzip middleware for API responses
-
-### Frontend
-
-- **Code Splitting:** Lazy load TipTap editor
-- **Virtualization:** Virtual scrolling for large file trees (react-window)
-- **Debouncing:** Auto-save with 2-second debounce
-- **Memoization:** React.memo for FileNode components
-
-### Docker
-
-- **Multi-stage Build:** Separate build and runtime images
-- **Layer Caching:** Optimize Dockerfile for faster rebuilds
-- **Image Size:** Use Alpine or scratch base
-
-## Open Questions & Future Decisions
-
-1. **Repository Size Limits:** What's the max repo size we'll support?
-2. **Concurrent Editing:** How to handle multiple browser tabs?
-3. **Image Embedding:** When we add image uploads, where to store (Git LFS, S3)?
-4. **MDX Support:** Custom TipTap extensions or separate editor mode?
-5. **Mobile Support:** Native app or PWA?
-6. **Offline Mode:** Service worker for offline editing?
-7. **Collaboration:** Real-time editing with WebSockets/CRDTs?
-
-## Success Metrics (Post-Launch)
-
-- **Technical:**
-  - Docker image < 50MB
-  - API response time < 200ms (p95)
-  - File tree render < 500ms for 1000 files
-  - Auto-save latency < 100ms
-
-- **User Experience:**
-  - OAuth flow completion rate > 90%
-  - Time to first edit < 30 seconds
-  - PR creation success rate > 95%
-
-## Next Steps
-
-1. **Set up development environment** (Go, Node.js, Docker)
-2. **Create GitHub OAuth app** for testing
-3. **Start with Phase 1:** Backend authentication
-4. **Daily commits** to track progress
-5. **Weekly demos** to validate UX
-
----
-
-## Additional Resources
-
-- **TipTap:** https://tiptap.dev/docs
-- **shadcn/ui:** https://ui.shadcn.com
-- **Astro with React:** https://docs.astro.build/en/guides/integrations-guide/react/
-- **go-git:** https://github.com/go-git/go-git
-- **goth:** https://github.com/markbates/goth
-- **Astro:** https://docs.astro.build
-- **React Query:** https://tanstack.com/query/latest
-
----
-
-**Document Version:** 1.0
-**Last Updated:** 2026-01-19
-**Status:** Draft - Ready for Implementation

backend/internal/api/handlers/branch.go

···
 package handlers
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"log"
···
 	repoFullName := fmt.Sprintf("%s/%s", owner, repo)
 	cloneURL := fmt.Sprintf("https://github.com/%s.git", repoFullName)
 
+	// Create GitHub client early (needed for rename operations)
+	ts := oauth2.StaticTokenSource(&oauth2.Token{AccessToken: token.AccessToken})
+	tc := oauth2.NewClient(ctx, ts)
+	client := github.NewClient(tc)
+
 	// Clone or open repository
 	gitRepo, err := h.gitOps.CloneOrOpen(ctx, repoFullName, cloneURL, token.AccessToken)
 	if err != nil {
···
 		return
 	}
 
-	// Get draft files and write them to the repository
-	filesToCommit := req.Files
-	if len(filesToCommit) == 0 {
-		// Get all draft files for this repository
-		// For now, we'll require files to be specified
-		http.Error(w, "No files specified to publish", http.StatusBadRequest)
+	// Get all draft changes for this repository
+	drafts, err := h.db.GetAllDraftContent(userID, repoFullName)
+	if err != nil {
+		log.Printf("Failed to get draft content: %v", err)
+		http.Error(w, "Failed to get draft content", http.StatusInternalServerError)
 		return
 	}
 
-	// Write draft content to repository files
-	for _, filePath := range filesToCommit {
-		draft, err := h.db.GetDraftContent(userID, repoFullName, filePath)
-		if err != nil {
-			log.Printf("Failed to get draft for %s: %v", filePath, err)
-			continue
-		}
-		if draft == nil {
-			log.Printf("No draft found for %s", filePath)
-			continue
-		}
+	if len(drafts) == 0 {
+		http.Error(w, "No pending changes to publish", http.StatusBadRequest)
+		return
+	}
 
-		if err := h.gitOps.WriteFile(repoFullName, filePath, draft.Content); err != nil {
-			log.Printf("Failed to write file %s: %v", filePath, err)
-			http.Error(w, fmt.Sprintf("Failed to write file: %v", err), http.StatusInternalServerError)
-			return
+	// Track all files that need to be committed
+	var filesToCommit []string
+
+	// Process each draft based on change type
+	for _, draft := range drafts {
+		switch draft.ChangeType {
+		case "edit", "new_file", "new_folder":
+			// For edits and new files/folders, write the content
+			if err := h.gitOps.WriteFile(repoFullName, draft.FilePath, draft.Content); err != nil {
+				log.Printf("Failed to write file %s: %v", draft.FilePath, err)
+				http.Error(w, fmt.Sprintf("Failed to write file: %v", err), http.StatusInternalServerError)
+				return
+			}
+			filesToCommit = append(filesToCommit, draft.FilePath)
+
+		case "rename":
+			// For renames, we need to:
+			// 1. Get content from the original file on GitHub
+			// 2. Write it to the new path
+			// 3. Stage the new file and the deletion
+			content, err := h.getFileContentFromGitHub(ctx, client, owner, repo, draft.OriginalPath)
+			if err != nil {
+				log.Printf("Failed to get content for rename from %s: %v", draft.OriginalPath, err)
+				http.Error(w, fmt.Sprintf("Failed to get file content for rename: %v", err), http.StatusInternalServerError)
+				return
+			}
+
+			// Write to new location
+			if err := h.gitOps.WriteFile(repoFullName, draft.FilePath, content); err != nil {
+				log.Printf("Failed to write renamed file %s: %v", draft.FilePath, err)
+				http.Error(w, fmt.Sprintf("Failed to write renamed file: %v", err), http.StatusInternalServerError)
+				return
+			}
+
+			// Delete old file
+			if err := h.gitOps.DeleteFile(repoFullName, draft.OriginalPath); err != nil {
+				log.Printf("Failed to delete renamed file %s: %v", draft.OriginalPath, err)
+				// Continue even if delete fails
+			}
+
+			filesToCommit = append(filesToCommit, draft.FilePath, draft.OriginalPath)
+
+		default:
+			// Treat unknown types as edits
+			if err := h.gitOps.WriteFile(repoFullName, draft.FilePath, draft.Content); err != nil {
+				log.Printf("Failed to write file %s: %v", draft.FilePath, err)
+				http.Error(w, fmt.Sprintf("Failed to write file: %v", err), http.StatusInternalServerError)
+				return
+			}
+			filesToCommit = append(filesToCommit, draft.FilePath)
 		}
 	}
 
···
 
 	log.Printf("Pushed branch %s", branchName)
 
-	// Create GitHub client
-	ts := oauth2.StaticTokenSource(&oauth2.Token{AccessToken: token.AccessToken})
-	tc := oauth2.NewClient(ctx, ts)
-	client := github.NewClient(tc)
-
 	// Create pull request
 	prTitle := req.PRTitle
 	if prTitle == "" {
···
 		log.Printf("Failed to update branch state: %v", err)
 	}
 
-	// Delete draft content for published files
-	for _, filePath := range filesToCommit {
-		if err := h.db.DeleteDraftContent(userID, repoFullName, filePath); err != nil {
-			log.Printf("Failed to delete draft for %s: %v", filePath, err)
-		}
+	// Delete all draft content for this repository after successful publish
+	if err := h.db.DeleteAllDraftContent(userID, repoFullName); err != nil {
+		log.Printf("Failed to delete draft content: %v", err)
 	}
 
 	response := PublishResponse{
···
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(response)
 }
+
+// getFileContentFromGitHub fetches the content of a file from GitHub
+func (h *BranchHandler) getFileContentFromGitHub(ctx context.Context, client *github.Client, owner, repo, path string) (string, error) {
+	fileContent, _, _, err := client.Repositories.GetContents(ctx, owner, repo, path, nil)
+	if err != nil {
+		return "", fmt.Errorf("failed to get file content from GitHub: %w", err)
+	}
+
+	if fileContent == nil {
+		return "", fmt.Errorf("file not found on GitHub")
+	}
+
+	content, err := fileContent.GetContent()
+	if err != nil {
+		return "", fmt.Errorf("failed to decode content: %w", err)
+	}
+
+	return content, nil
+}

backend/internal/api/handlers/repos.go

···
 	"log"
 	"net/http"
 	"strings"
+	"time"
 
 	"github.com/go-chi/chi/v5"
 	"github.com/yourusername/markedit/internal/auth"
···
 		"invalidated_count": count,
 	})
 }
+
+// CreateFileRequest represents the request to create a new file
+type CreateFileRequest struct {
+	Path    string `json:"path"`
+	Content string `json:"content"`
+	Message string `json:"message"`
+}
+
+// CreateFile creates a new file as a draft change (not immediately pushed)
+func (h *RepoHandler) CreateFile(w http.ResponseWriter, r *http.Request) {
+	owner := chi.URLParam(r, "owner")
+	repo := chi.URLParam(r, "repo")
+
+	if owner == "" || repo == "" {
+		http.Error(w, "Missing owner or repo parameter", http.StatusBadRequest)
+		return
+	}
+
+	// Get user from session
+	session, err := auth.GetSession(r)
+	if err != nil {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	userID, ok := auth.GetUserID(session)
+	if !ok {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	// Parse request body
+	var req CreateFileRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "Invalid request body", http.StatusBadRequest)
+		return
+	}
+
+	if req.Path == "" {
+		http.Error(w, "Path is required", http.StatusBadRequest)
+		return
+	}
+
+	// Save as draft instead of creating immediately
+	repoFullName := fmt.Sprintf("%s/%s", owner, repo)
+	draft := &database.DraftContent{
+		UserID:       userID,
+		RepoFullName: repoFullName,
+		FilePath:     req.Path,
+		Content:      req.Content,
+		ChangeType:   "new_file",
+	}
+
+	if err := h.db.SaveDraftContent(draft); err != nil {
+		log.Printf("Failed to save draft for new file: %v", err)
+		http.Error(w, "Failed to save draft", http.StatusInternalServerError)
+		return
+	}
+
+	// Update branch state to indicate uncommitted changes
+	state := &database.BranchState{
+		UserID:                userID,
+		RepoFullName:          repoFullName,
+		BranchName:            "",
+		BaseBranch:            "main",
+		LastPushAt:            time.Now(),
+		HasUncommittedChanges: true,
+		FilePaths:             fmt.Sprintf("[\"%s\"]", req.Path),
+	}
+	if err := h.db.SaveBranchState(state); err != nil {
+		log.Printf("Warning: Failed to save branch state: %v", err)
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]interface{}{
+		"success":     true,
+		"path":        req.Path,
+		"draft_saved": true,
+	})
+}
+
+// CreateFolderRequest represents the request to create a new folder
+type CreateFolderRequest struct {
+	Path    string `json:"path"`
+	Message string `json:"message"`
+}
+
+// CreateFolder creates a new folder as a draft change (not immediately pushed)
+func (h *RepoHandler) CreateFolder(w http.ResponseWriter, r *http.Request) {
+	owner := chi.URLParam(r, "owner")
+	repo := chi.URLParam(r, "repo")
+
+	if owner == "" || repo == "" {
+		http.Error(w, "Missing owner or repo parameter", http.StatusBadRequest)
+		return
+	}
+
+	// Get user from session
+	session, err := auth.GetSession(r)
+	if err != nil {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	userID, ok := auth.GetUserID(session)
+	if !ok {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	// Parse request body
+	var req CreateFolderRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "Invalid request body", http.StatusBadRequest)
+		return
+	}
+
+	if req.Path == "" {
+		http.Error(w, "Path is required", http.StatusBadRequest)
+		return
+	}
+
+	// Save as draft instead of creating immediately
+	repoFullName := fmt.Sprintf("%s/%s", owner, repo)
+	folderPath := strings.TrimSuffix(req.Path, "/")
+	gitkeepPath := folderPath + "/.gitkeep"
+
+	draft := &database.DraftContent{
+		UserID:       userID,
+		RepoFullName: repoFullName,
+		FilePath:     gitkeepPath,
+		Content:      "",
+		ChangeType:   "new_folder",
+	}
+
+	if err := h.db.SaveDraftContent(draft); err != nil {
+		log.Printf("Failed to save draft for new folder: %v", err)
+		http.Error(w, "Failed to save draft", http.StatusInternalServerError)
+		return
+	}
+
+	// Update branch state to indicate uncommitted changes
+	state := &database.BranchState{
+		UserID:                userID,
+		RepoFullName:          repoFullName,
+		BranchName:            "",
+		BaseBranch:            "main",
+		LastPushAt:            time.Now(),
+		HasUncommittedChanges: true,
+		FilePaths:             fmt.Sprintf("[\"%s\"]", gitkeepPath),
+	}
+	if err := h.db.SaveBranchState(state); err != nil {
+		log.Printf("Warning: Failed to save branch state: %v", err)
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]interface{}{
+		"success":     true,
+		"path":        folderPath,
+		"draft_saved": true,
+	})
+}
+
+// RenameItemRequest represents the request to rename a file or folder
+type RenameItemRequest struct {
+	OldPath string `json:"old_path"`
+	NewPath string `json:"new_path"`
+	Message string `json:"message"`
+}
+
+// RenameItem saves a rename operation as a draft change (not immediately pushed)
+func (h *RepoHandler) RenameItem(w http.ResponseWriter, r *http.Request) {
+	owner := chi.URLParam(r, "owner")
+	repo := chi.URLParam(r, "repo")
+
+	if owner == "" || repo == "" {
+		http.Error(w, "Missing owner or repo parameter", http.StatusBadRequest)
+		return
+	}
+
+	// Get user from session
+	session, err := auth.GetSession(r)
+	if err != nil {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	userID, ok := auth.GetUserID(session)
+	if !ok {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	// Parse request body
+	var req RenameItemRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "Invalid request body", http.StatusBadRequest)
+		return
+	}
+
+	if req.OldPath == "" || req.NewPath == "" {
+		http.Error(w, "Both old_path and new_path are required", http.StatusBadRequest)
+		return
+	}
+
+	// Save as draft instead of renaming immediately
+	repoFullName := fmt.Sprintf("%s/%s", owner, repo)
+
+	// For renames, we store the new path as file_path and old path as original_path
+	draft := &database.DraftContent{
+		UserID:       userID,
+		RepoFullName: repoFullName,
+		FilePath:     req.NewPath,
+		Content:      "", // Content will be fetched from original file during publish
+		ChangeType:   "rename",
+		OriginalPath: req.OldPath,
+	}
+
+	if err := h.db.SaveDraftContent(draft); err != nil {
+		log.Printf("Failed to save draft for rename: %v", err)
+		http.Error(w, "Failed to save draft", http.StatusInternalServerError)
+		return
+	}
+
+	// Update branch state to indicate uncommitted changes
+	state := &database.BranchState{
+		UserID:                userID,
+		RepoFullName:          repoFullName,
+		BranchName:            "",
+		BaseBranch:            "main",
+		LastPushAt:            time.Now(),
+		HasUncommittedChanges: true,
+		FilePaths:             fmt.Sprintf("[\"%s\"]", req.NewPath),
+	}
+	if err := h.db.SaveBranchState(state); err != nil {
+		log.Printf("Warning: Failed to save branch state: %v", err)
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]interface{}{
+		"success":     true,
+		"old_path":    req.OldPath,
+		"new_path":    req.NewPath,
+		"draft_saved": true,
+	})
+}
+
+// GetPendingChanges returns all pending draft changes for a repository
+func (h *RepoHandler) GetPendingChanges(w http.ResponseWriter, r *http.Request) {
+	owner := chi.URLParam(r, "owner")
+	repo := chi.URLParam(r, "repo")
+
+	if owner == "" || repo == "" {
+		http.Error(w, "Missing owner or repo parameter", http.StatusBadRequest)
+		return
+	}
+
+	// Get user from session
+	session, err := auth.GetSession(r)
+	if err != nil {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	userID, ok := auth.GetUserID(session)
+	if !ok {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	repoFullName := fmt.Sprintf("%s/%s", owner, repo)
+
+	// Get all draft content for this repository
+	drafts, err := h.db.GetAllDraftContent(userID, repoFullName)
+	if err != nil {
+		log.Printf("Failed to get pending changes: %v", err)
+		http.Error(w, "Failed to get pending changes", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]interface{}{
+		"pending_changes": drafts,
+		"count":           len(drafts),
+	})
+}
+
+// DiscardChanges removes all pending draft changes for a repository
+func (h *RepoHandler) DiscardChanges(w http.ResponseWriter, r *http.Request) {
+	owner := chi.URLParam(r, "owner")
+	repo := chi.URLParam(r, "repo")
+
+	if owner == "" || repo == "" {
+		http.Error(w, "Missing owner or repo parameter", http.StatusBadRequest)
+		return
+	}
+
+	// Get user from session
+	session, err := auth.GetSession(r)
+	if err != nil {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	userID, ok := auth.GetUserID(session)
+	if !ok {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	repoFullName := fmt.Sprintf("%s/%s", owner, repo)
+
+	// Delete all draft content for this repository
+	if err := h.db.DeleteAllDraftContent(userID, repoFullName); err != nil {
+		log.Printf("Failed to discard changes: %v", err)
+		http.Error(w, "Failed to discard changes", http.StatusInternalServerError)
+		return
+	}
+
+	// Reset branch state to indicate no uncommitted changes
+	state := &database.BranchState{
+		UserID:                userID,
+		RepoFullName:          repoFullName,
+		BranchName:            "",
+		BaseBranch:            "main",
+		LastPushAt:            time.Now(),
+		HasUncommittedChanges: false,
+		FilePaths:             "[]",
+	}
+	if err := h.db.SaveBranchState(state); err != nil {
+		log.Printf("Warning: Failed to update branch state: %v", err)
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]interface{}{
+		"success": true,
+		"message": "All pending changes have been discarded",
+	})
+}

backend/internal/api/router.go

···
 		r.Put("/api/repos/{owner}/{repo}/files/*", repoHandler.UpdateFileContent)
 		r.Delete("/api/repos/{owner}/{repo}/cache", repoHandler.InvalidateCache)
 
+		// File management routes
+		r.Post("/api/repos/{owner}/{repo}/create-file", repoHandler.CreateFile)
+		r.Post("/api/repos/{owner}/{repo}/create-folder", repoHandler.CreateFolder)
+		r.Post("/api/repos/{owner}/{repo}/rename", repoHandler.RenameItem)
+		r.Get("/api/repos/{owner}/{repo}/pending-changes", repoHandler.GetPendingChanges)
+		r.Delete("/api/repos/{owner}/{repo}/pending-changes", repoHandler.DiscardChanges)
+
 		// Branch routes
 		r.Get("/api/repos/{owner}/{repo}/branch/status", branchHandler.GetBranchStatus)
 		r.Post("/api/repos/{owner}/{repo}/publish", branchHandler.Publish)

backend/internal/connectors/github.go

···
 
 import (
 	"context"
+	"encoding/base64"
 	"fmt"
 	"os"
 	"path/filepath"
···
 	pattern := fmt.Sprintf("%s/%s/*", owner, repo)
 	return globalCache.InvalidatePattern(pattern)
 }
+
+// CreateFile creates a new file in the repository
+func (g *GitHubConnector) CreateFile(ctx context.Context, owner, repo, path, content, message string) error {
+	if message == "" {
+		message = fmt.Sprintf("Create %s", path)
+	}
+
+	// Get default branch
+	repository, _, err := g.client.Repositories.Get(ctx, owner, repo)
+	if err != nil {
+		return fmt.Errorf("failed to get repository: %w", err)
+	}
+	branch := repository.GetDefaultBranch()
+
+	// Encode content to base64
+	encodedContent := github.String(base64.StdEncoding.EncodeToString([]byte(content)))
+
+	// Create file options
+	opts := &github.RepositoryContentFileOptions{
+		Message: github.String(message),
+		Content: []byte(*encodedContent),
+		Branch:  github.String(branch),
+	}
+
+	// Create the file
+	_, _, err = g.client.Repositories.CreateFile(ctx, owner, repo, path, opts)
+	if err != nil {
+		return fmt.Errorf("failed to create file: %w", err)
+	}
+
+	return nil
+}
+
+// RenameItem renames a file or folder by deleting the old path and creating at the new path
+func (g *GitHubConnector) RenameItem(ctx context.Context, owner, repo, oldPath, newPath, message string) error {
+	if message == "" {
+		message = fmt.Sprintf("Rename %s to %s", oldPath, newPath)
+	}
+
+	// Get default branch
+	repository, _, err := g.client.Repositories.Get(ctx, owner, repo)
+	if err != nil {
+		return fmt.Errorf("failed to get repository: %w", err)
+	}
+	branch := repository.GetDefaultBranch()
+
+	// Get the content of the old file/path
+	fileContent, _, _, err := g.client.Repositories.GetContents(ctx, owner, repo, oldPath, &github.RepositoryContentGetOptions{
+		Ref: branch,
+	})
+	if err != nil {
+		return fmt.Errorf("failed to get file content: %w", err)
+	}
+
+	// If it's a directory, we need to handle all files in it
+	if fileContent == nil {
+		// It's a directory - get all files in it
+		_, directoryContent, _, err := g.client.Repositories.GetContents(ctx, owner, repo, oldPath, &github.RepositoryContentGetOptions{
+			Ref: branch,
+		})
+		if err != nil {
+			return fmt.Errorf("failed to get directory contents: %w", err)
+		}
+
+		// Rename each file in the directory
+		for _, item := range directoryContent {
+			if item.GetType() == "file" {
+				oldFilePath := item.GetPath()
+				newFilePath := strings.Replace(oldFilePath, oldPath, newPath, 1)
+
+				// Get file content
+				content, err := item.GetContent()
+				if err != nil {
+					return fmt.Errorf("failed to get content for %s: %w", oldFilePath, err)
+				}
+
+				// Create new file
+				encodedContent := base64.StdEncoding.EncodeToString([]byte(content))
+				opts := &github.RepositoryContentFileOptions{
+					Message: github.String(message),
+					Content: []byte(encodedContent),
+					Branch:  github.String(branch),
+				}
+				_, _, err = g.client.Repositories.CreateFile(ctx, owner, repo, newFilePath, opts)
+				if err != nil {
+					return fmt.Errorf("failed to create file %s: %w", newFilePath, err)
+				}
+
+				// Delete old file
+				deleteOpts := &github.RepositoryContentFileOptions{
+					Message: github.String(message),
+					SHA:     github.String(item.GetSHA()),
+					Branch:  github.String(branch),
+				}
+				_, _, err = g.client.Repositories.DeleteFile(ctx, owner, repo, oldFilePath, deleteOpts)
+				if err != nil {
+					return fmt.Errorf("failed to delete file %s: %w", oldFilePath, err)
+				}
+			}
+		}
+	} else {
+		// It's a single file
+		content, err := fileContent.GetContent()
+		if err != nil {
+			return fmt.Errorf("failed to get file content: %w", err)
+		}
+
+		// Create new file at new path
+		encodedContent := base64.StdEncoding.EncodeToString([]byte(content))
+		opts := &github.RepositoryContentFileOptions{
+			Message: github.String(message),
+			Content: []byte(encodedContent),
+			Branch:  github.String(branch),
+		}
+		_, _, err = g.client.Repositories.CreateFile(ctx, owner, repo, newPath, opts)
+		if err != nil {
+			return fmt.Errorf("failed to create file at new path: %w", err)
+		}
+
+		// Delete old file
+		deleteOpts := &github.RepositoryContentFileOptions{
+			Message: github.String(message),
+			SHA:     github.String(fileContent.GetSHA()),
+			Branch:  github.String(branch),
+		}
+		_, _, err = g.client.Repositories.DeleteFile(ctx, owner, repo, oldPath, deleteOpts)
+		if err != nil {
+			return fmt.Errorf("failed to delete old file: %w", err)
+		}
+	}
+
+	return nil
+}

backend/internal/database/migrations/002_add_change_type.sql

···
+-- Migration: Add change_type and original_path to draft_content
+-- This allows tracking different types of changes (edit, new_file, new_folder, rename)
+-- This migration is idempotent and handles cases where columns might already exist
+
+-- Create a temporary table with the new schema
+CREATE TABLE IF NOT EXISTS draft_content_new (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    user_id INTEGER NOT NULL,
+    repo_full_name TEXT NOT NULL,
+    file_path TEXT NOT NULL,
+    content TEXT NOT NULL,
+    change_type TEXT DEFAULT 'edit',
+    original_path TEXT,
+    last_saved_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    UNIQUE(user_id, repo_full_name, file_path),
+    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
+);
+
+-- Copy data from old table if it exists
+INSERT OR IGNORE INTO draft_content_new (id, user_id, repo_full_name, file_path, content, change_type, original_path, last_saved_at)
+SELECT id, user_id, repo_full_name, file_path, content, 
+       COALESCE(change_type, 'edit') as change_type,
+       original_path,
+       last_saved_at
+FROM draft_content;
+
+-- Drop old table
+DROP TABLE IF EXISTS draft_content;
+
+-- Rename new table to old name
+ALTER TABLE draft_content_new RENAME TO draft_content;
+
+-- Create index for efficient querying by change_type
+CREATE INDEX IF NOT EXISTS idx_draft_content_change_type ON draft_content(user_id, repo_full_name, change_type);
+
+-- Create original index if it doesn't exist
+CREATE INDEX IF NOT EXISTS idx_draft_content_user_repo_file ON draft_content(user_id, repo_full_name, file_path);

backend/internal/database/models.go

···
 	RepoFullName string    `json:"repo_full_name"`
 	FilePath     string    `json:"file_path"`
 	Content      string    `json:"content"`
+	ChangeType   string    `json:"change_type"`   // 'edit', 'new_file', 'new_folder', 'rename'
+	OriginalPath string    `json:"original_path"` // For renames: old path
 	LastSavedAt  time.Time `json:"last_saved_at"`
 }
 

backend/internal/database/queries.go

···
 // SaveDraftContent saves or updates draft content for a file
 func (db *DB) SaveDraftContent(draft *DraftContent) error {
 	query := `
-		INSERT INTO draft_content (user_id, repo_full_name, file_path, content, last_saved_at)
-		VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP)
+		INSERT INTO draft_content (user_id, repo_full_name, file_path, content, change_type, original_path, last_saved_at)
+		VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
 		ON CONFLICT(user_id, repo_full_name, file_path) DO UPDATE SET
 			content = excluded.content,
+			change_type = excluded.change_type,
+			original_path = excluded.original_path,
 			last_saved_at = CURRENT_TIMESTAMP
 		RETURNING id, last_saved_at
 	`
···
 		draft.RepoFullName,
 		draft.FilePath,
 		draft.Content,
+		draft.ChangeType,
+		draft.OriginalPath,
 	).Scan(&draft.ID, &draft.LastSavedAt)
 }
 
···
 func (db *DB) GetDraftContent(userID int, repoFullName, filePath string) (*DraftContent, error) {
 	draft := &DraftContent{}
 	query := `
-		SELECT id, user_id, repo_full_name, file_path, content, last_saved_at
+		SELECT id, user_id, repo_full_name, file_path, content, change_type, original_path, last_saved_at
 		FROM draft_content
 		WHERE user_id = ? AND repo_full_name = ? AND file_path = ?
 	`
···
 		&draft.RepoFullName,
 		&draft.FilePath,
 		&draft.Content,
+		&draft.ChangeType,
+		&draft.OriginalPath,
 		&draft.LastSavedAt,
 	)
 
···
 	_, err := db.Exec(query, userID, repoFullName, filePath)
 	if err != nil {
 		return fmt.Errorf("failed to delete draft: %w", err)
+	}
+
+	return nil
+}
+
+// GetAllDraftContent retrieves all draft content for a repository
+func (db *DB) GetAllDraftContent(userID int, repoFullName string) ([]*DraftContent, error) {
+	query := `
+		SELECT id, user_id, repo_full_name, file_path, content, change_type, original_path, last_saved_at
+		FROM draft_content
+		WHERE user_id = ? AND repo_full_name = ?
+		ORDER BY last_saved_at DESC
+	`
+
+	rows, err := db.Query(query, userID, repoFullName)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get all drafts: %w", err)
+	}
+	defer rows.Close()
+
+	var drafts []*DraftContent
+	for rows.Next() {
+		draft := &DraftContent{}
+		err := rows.Scan(
+			&draft.ID,
+			&draft.UserID,
+			&draft.RepoFullName,
+			&draft.FilePath,
+			&draft.Content,
+			&draft.ChangeType,
+			&draft.OriginalPath,
+			&draft.LastSavedAt,
+		)
+		if err != nil {
+			return nil, fmt.Errorf("failed to scan draft row: %w", err)
+		}
+		drafts = append(drafts, draft)
+	}
+
+	return drafts, nil
+}
+
+// DeleteAllDraftContent deletes all draft content for a repository
+func (db *DB) DeleteAllDraftContent(userID int, repoFullName string) error {
+	query := `
+		DELETE FROM draft_content
+		WHERE user_id = ? AND repo_full_name = ?
+	`
+
+	_, err := db.Exec(query, userID, repoFullName)
+	if err != nil {
+		return fmt.Errorf("failed to delete all drafts: %w", err)
 	}
 
 	return nil

backend/internal/git/operations.go

···
 
 	return head.Name().Short(), nil
 }
+
+// DeleteFile removes a file from the repository worktree
+func (g *GitOperations) DeleteFile(repoFullName, filePath string) error {
+	repoPath := g.getRepoPath(repoFullName)
+	fullPath := filepath.Join(repoPath, filePath)
+
+	if err := os.Remove(fullPath); err != nil && !os.IsNotExist(err) {
+		return fmt.Errorf("failed to delete file: %w", err)
+	}
+
+	return nil
+}

frontend/src/components/dashboard/DashboardApp.tsx

···
 import { useState, useEffect } from 'react';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
-import { Toaster } from 'sonner';
+import { Toaster, toast } from 'sonner';
 import { Header } from '../layout/Header';
 import { FileTree } from './FileTree';
 import { FileTreeHeader } from './FileTreeHeader';
 import { EditorContainer } from '../editor/EditorContainer';
-import { useFiles } from '../../lib/hooks/useRepos';
+import { useFiles, useCreateFile, useCreateFolder, useRenameItem, usePendingChanges, useDiscardChanges } from '../../lib/hooks/useRepos';
 import { useCurrentUser, useUserRepos } from '../../lib/hooks/useAuth';
+import { useBranchStatus, usePublish } from '../../lib/hooks/useBranch';
 import { Loading } from '../ui/Loading';
 import { EmptyState } from '../ui/EmptyState';
 
···
   const { data: user, isLoading: userLoading } = useCurrentUser();
   const { data: userRepos, isLoading: reposLoading } = useUserRepos();
 
+  // Modal states for creating files/folders
+  const [createModalOpen, setCreateModalOpen] = useState(false);
+  const [createModalType, setCreateModalType] = useState<'file' | 'folder'>('file');
+  const [createModalPath, setCreateModalPath] = useState('');
+  const [newItemName, setNewItemName] = useState('');
+
+  // Mutations
+  const createFileMutation = useCreateFile(repoConfig?.owner || '', repoConfig?.repo || '');
+  const createFolderMutation = useCreateFolder(repoConfig?.owner || '', repoConfig?.repo || '');
+  const renameItemMutation = useRenameItem(repoConfig?.owner || '', repoConfig?.repo || '');
+  const publishMutation = usePublish();
+  const discardChangesMutation = useDiscardChanges(repoConfig?.owner || '', repoConfig?.repo || '');
+
+  // Check for pending changes
+  const { data: pendingChanges } = usePendingChanges(
+    repoConfig?.owner || '',
+    repoConfig?.repo || ''
+  );
+  const { data: branchStatus } = useBranchStatus(
+    repoConfig?.owner || '',
+    repoConfig?.repo || ''
+  );
+
+  // Dialog states
+  const [publishDialogOpen, setPublishDialogOpen] = useState(false);
+  const [discardDialogOpen, setDiscardDialogOpen] = useState(false);
+  const [commitMessage, setCommitMessage] = useState('');
+  const [prTitle, setPrTitle] = useState('');
+
+  // Determine if there are pending changes
+  const hasPendingChanges = pendingChanges && pendingChanges.count > 0;
+
   // Check for repo from URL params, user.last_repo, or user_repos table
   useEffect(() => {
     if (userLoading || reposLoading || !user) {
···
     ['md', 'mdx']
   );
 
+  // Handlers for file operations
+  const handleCreateFile = (parentPath: string) => {
+    setCreateModalType('file');
+    setCreateModalPath(parentPath);
+    setNewItemName('');
+    setCreateModalOpen(true);
+  };
+
+  const handleCreateFolder = (parentPath: string) => {
+    setCreateModalType('folder');
+    setCreateModalPath(parentPath);
+    setNewItemName('');
+    setCreateModalOpen(true);
+  };
+
+  const handleCreateSubmit = async () => {
+    if (!newItemName.trim() || !repoConfig) return;
+
+    // Replace spaces with hyphens
+    const sanitizedName = newItemName.trim().replace(/\s+/g, '-');
+
+    const fullPath = createModalPath
+      ? `${createModalPath}/${sanitizedName}`
+      : sanitizedName;
+
+    try {
+      if (createModalType === 'file') {
+        // Ensure file has .md or .mdx extension
+        let filePath = fullPath;
+        if (!filePath.endsWith('.md') && !filePath.endsWith('.mdx')) {
+          filePath += '.md';
+        }
+        await createFileMutation.mutateAsync({ path: filePath, content: '', message: `Create ${filePath}` });
+        toast.success(`File "${filePath}" created successfully`);
+      } else {
+        await createFolderMutation.mutateAsync({ path: fullPath, message: `Create folder ${fullPath}` });
+        toast.success(`Folder "${fullPath}" created successfully`);
+      }
+      setCreateModalOpen(false);
+      setNewItemName('');
+    } catch (error) {
+      toast.error(`Failed to create ${createModalType}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  };
+
+  const handleRename = async (oldPath: string, newName: string) => {
+    if (!repoConfig || !newName.trim() || newName === oldPath.split('/').pop()) return;
+
+    // Ensure .md extension for files if not present
+    let finalName = newName.trim();
+    if (!finalName.endsWith('.md') && !finalName.endsWith('.mdx')) {
+      finalName += '.md';
+    }
+
+    const pathParts = oldPath.split('/');
+    pathParts[pathParts.length - 1] = finalName;
+    const newPath = pathParts.join('/');
+
+    try {
+      await renameItemMutation.mutateAsync({
+        oldPath,
+        newPath,
+        message: `Rename ${oldPath} to ${newPath}`,
+      });
+      toast.success(`Renamed to "${newName}" successfully`);
+
+      // If the renamed file was selected, update the selected file
+      if (selectedFile === oldPath) {
+        setSelectedFile(newPath);
+      }
+    } catch (error) {
+      toast.error(`Failed to rename: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  };
+
+  const handlePublish = async () => {
+    if (!repoConfig || !commitMessage.trim()) return;
+
+    try {
+      await publishMutation.mutateAsync({
+        owner: repoConfig.owner,
+        repo: repoConfig.repo,
+        commit_message: commitMessage,
+        pr_title: prTitle.trim() || commitMessage,
+      });
+      toast.success('Changes published successfully!');
+      setPublishDialogOpen(false);
+      setCommitMessage('');
+      setPrTitle('');
+    } catch (error) {
+      toast.error(`Failed to publish: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  };
+
+  const handleDiscard = async () => {
+    if (!repoConfig) return;
+
+    try {
+      await discardChangesMutation.mutateAsync();
+      toast.success('All pending changes have been discarded');
+      setDiscardDialogOpen(false);
+    } catch (error) {
+      toast.error(`Failed to discard changes: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  };
+
   if (userLoading || reposLoading) {
     return (
       <div className="min-h-screen bg-gray-50 flex items-center justify-center">
···
               files={filesData.files}
               selectedFile={selectedFile}
               onSelectFile={setSelectedFile}
+              owner={repoConfig.owner}
+              repo={repoConfig.repo}
+              onCreateFile={handleCreateFile}
+              onCreateFolder={handleCreateFolder}
+              onRename={handleRename}
             />
           ) : (
             <div className="p-4">
···
           )}
         </main>
       </div>
+
+      {/* Create File/Folder Modal */}
+      {createModalOpen && (
+        <div className="fixed inset-0 bg-black/50 flex items-center justify-center z-50">
+          <div className="bg-white rounded-lg shadow-xl p-6 w-full max-w-md">
+            <h3 className="text-lg font-semibold text-gray-900 mb-4">
+              Create New {createModalType === 'file' ? 'File' : 'Folder'}
+            </h3>
+            <p className="text-sm text-gray-600 mb-4">
+              in {createModalPath || 'root'}
+            </p>
+            <input
+              type="text"
+              value={newItemName}
+              onChange={(e) => setNewItemName(e.target.value)}
+              onKeyDown={(e) => {
+                if (e.key === 'Enter') handleCreateSubmit();
+                if (e.key === 'Escape') setCreateModalOpen(false);
+              }}
+              placeholder={createModalType === 'file' ? 'filename.md' : 'folder-name'}
+              className="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-gray-900"
+              autoFocus
+            />
+            <div className="flex justify-end gap-2 mt-6">
+              <button
+                onClick={() => setCreateModalOpen(false)}
+                className="px-4 py-2 text-sm text-gray-600 hover:text-gray-900"
+              >
+                Cancel
+              </button>
+              <button
+                onClick={handleCreateSubmit}
+                disabled={!newItemName.trim() || createFileMutation.isPending || createFolderMutation.isPending}
+                className="px-4 py-2 text-sm bg-gray-900 text-white rounded-md hover:bg-gray-800 disabled:opacity-50 disabled:cursor-not-allowed"
+              >
+                {createFileMutation.isPending || createFolderMutation.isPending
+                  ? 'Creating...'
+                  : 'Create'}
+              </button>
+            </div>
+          </div>
+        </div>
+      )}
+
+      {/* Global Publish/Discard Buttons - shows when there are pending changes */}
+      {hasPendingChanges && (
+        <div className="fixed bottom-6 right-6 z-40 flex items-center gap-3">
+          {/* Discard Button */}
+          <button
+            onClick={() => setDiscardDialogOpen(true)}
+            disabled={discardChangesMutation.isPending}
+            className="flex items-center gap-2 px-4 py-3 bg-white text-red-600 border border-red-200 rounded-full shadow-lg hover:bg-red-50 disabled:opacity-50 disabled:cursor-not-allowed transition-all"
+            title="Discard all pending changes"
+          >
+            <svg className="w-5 h-5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6m1-10V4a1 1 0 00-1-1h-4a1 1 0 00-1 1v3M4 7h16" />
+            </svg>
+            <span className="font-medium">
+              {discardChangesMutation.isPending ? 'Discarding...' : 'Discard'}
+            </span>
+          </button>
+
+          {/* Publish Button */}
+          <button
+            onClick={() => setPublishDialogOpen(true)}
+            disabled={publishMutation.isPending}
+            className="flex items-center gap-2 px-6 py-3 bg-gray-900 text-white rounded-full shadow-lg hover:bg-gray-800 disabled:opacity-50 disabled:cursor-not-allowed transition-all hover:scale-105"
+          >
+            <svg className="w-5 h-5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M7 16a4 4 0 01-.88-7.903A5 5 0 1115.9 6L16 6a5 5 0 011 9.9M15 13l-3-3m0 0l-3 3m3-3v12" />
+            </svg>
+            <span className="font-medium">
+              {publishMutation.isPending ? 'Publishing...' : `Publish Changes (${pendingChanges?.count})`}
+            </span>
+          </button>
+        </div>
+      )}
+
+      {/* Publish Dialog */}
+      {publishDialogOpen && (
+        <div className="fixed inset-0 bg-black/50 flex items-center justify-center z-50">
+          <div className="bg-white rounded-lg shadow-xl p-6 w-full max-w-md">
+            <h3 className="text-lg font-semibold text-gray-900 mb-2">
+              Publish Changes
+            </h3>
+            <p className="text-sm text-gray-600 mb-4">
+              {pendingChanges?.count} pending change(s) will be committed and a pull request will be created.
+            </p>
+            
+            <div className="space-y-4">
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1">
+                  Commit Message *
+                </label>
+                <input
+                  type="text"
+                  value={commitMessage}
+                  onChange={(e) => setCommitMessage(e.target.value)}
+                  onKeyDown={(e) => {
+                    if (e.key === 'Enter' && commitMessage.trim()) handlePublish();
+                    if (e.key === 'Escape') setPublishDialogOpen(false);
+                  }}
+                  placeholder="e.g., Update blog posts"
+                  className="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-gray-900"
+                  autoFocus
+                />
+              </div>
+              
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1">
+                  Pull Request Title (optional)
+                </label>
+                <input
+                  type="text"
+                  value={prTitle}
+                  onChange={(e) => setPrTitle(e.target.value)}
+                  placeholder="Defaults to commit message"
+                  className="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-gray-900"
+                />
+              </div>
+
+              {pendingChanges && pendingChanges.pending_changes && pendingChanges.pending_changes.length > 0 && (
+                <div className="bg-gray-50 rounded-md p-3">
+                  <p className="text-xs font-medium text-gray-700 mb-2">Changed files:</p>
+                  <ul className="text-xs text-gray-600 space-y-1 max-h-32 overflow-y-auto">
+                    {pendingChanges.pending_changes.map((change: any) => (
+                      <li key={change.id} className="flex items-center gap-2">
+                        <span className={`
+                          px-1.5 py-0.5 rounded text-[10px] font-medium uppercase
+                          ${change.change_type === 'new_file' ? 'bg-green-100 text-green-700' : ''}
+                          ${change.change_type === 'new_folder' ? 'bg-blue-100 text-blue-700' : ''}
+                          ${change.change_type === 'rename' ? 'bg-yellow-100 text-yellow-700' : ''}
+                          ${change.change_type === 'edit' ? 'bg-gray-100 text-gray-700' : ''}
+                        `}>
+                          {change.change_type === 'new_file' && 'New'}
+                          {change.change_type === 'new_folder' && 'Folder'}
+                          {change.change_type === 'rename' && 'Renamed'}
+                          {change.change_type === 'edit' && 'Edit'}
+                        </span>
+                        <span className="truncate">{change.file_path}</span>
+                      </li>
+                    ))}
+                  </ul>
+                </div>
+              )}
+            </div>
+
+            <div className="flex justify-end gap-2 mt-6">
+              <button
+                onClick={() => {
+                  setPublishDialogOpen(false);
+                  setCommitMessage('');
+                  setPrTitle('');
+                }}
+                className="px-4 py-2 text-sm text-gray-600 hover:text-gray-900"
+              >
+                Cancel
+              </button>
+              <button
+                onClick={handlePublish}
+                disabled={!commitMessage.trim() || publishMutation.isPending}
+                className="px-4 py-2 text-sm bg-gray-900 text-white rounded-md hover:bg-gray-800 disabled:opacity-50 disabled:cursor-not-allowed"
+              >
+                {publishMutation.isPending ? 'Publishing...' : 'Publish'}
+              </button>
+            </div>
+          </div>
+        </div>
+      )}
+
+      {/* Discard Confirmation Dialog */}
+      {discardDialogOpen && (
+        <div className="fixed inset-0 bg-black/50 flex items-center justify-center z-50">
+          <div className="bg-white rounded-lg shadow-xl p-6 w-full max-w-md">
+            <div className="flex items-center gap-3 mb-4">
+              <div className="p-2 bg-red-100 rounded-full">
+                <svg className="w-6 h-6 text-red-600" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z" />
+                </svg>
+              </div>
+              <h3 className="text-lg font-semibold text-gray-900">
+                Discard All Changes?
+              </h3>
+            </div>
+            
+            <p className="text-sm text-gray-600 mb-4">
+              This will permanently delete all {pendingChanges?.count} pending change(s). This action cannot be undone.
+            </p>
+
+            {pendingChanges && pendingChanges.pending_changes && pendingChanges.pending_changes.length > 0 && (
+              <div className="bg-gray-50 rounded-md p-3 mb-4">
+                <p className="text-xs font-medium text-gray-700 mb-2">Changes to be discarded:</p>
+                <ul className="text-xs text-gray-600 space-y-1 max-h-32 overflow-y-auto">
+                  {pendingChanges.pending_changes.map((change: any) => (
+                    <li key={change.id} className="flex items-center gap-2">
+                      <span className={`
+                        px-1.5 py-0.5 rounded text-[10px] font-medium uppercase
+                        ${change.change_type === 'new_file' ? 'bg-green-100 text-green-700' : ''}
+                        ${change.change_type === 'new_folder' ? 'bg-blue-100 text-blue-700' : ''}
+                        ${change.change_type === 'rename' ? 'bg-yellow-100 text-yellow-700' : ''}
+                        ${change.change_type === 'edit' ? 'bg-gray-100 text-gray-700' : ''}
+                      `}>
+                        {change.change_type === 'new_file' && 'New'}
+                        {change.change_type === 'new_folder' && 'Folder'}
+                        {change.change_type === 'rename' && 'Renamed'}
+                        {change.change_type === 'edit' && 'Edit'}
+                      </span>
+                      <span className="truncate">{change.file_path}</span>
+                    </li>
+                  ))}
+                </ul>
+              </div>
+            )}
+
+            <div className="flex justify-end gap-2">
+              <button
+                onClick={() => setDiscardDialogOpen(false)}
+                className="px-4 py-2 text-sm text-gray-600 hover:text-gray-900"
+              >
+                Cancel
+              </button>
+              <button
+                onClick={handleDiscard}
+                disabled={discardChangesMutation.isPending}
+                className="px-4 py-2 text-sm bg-red-600 text-white rounded-md hover:bg-red-700 disabled:opacity-50 disabled:cursor-not-allowed"
+              >
+                {discardChangesMutation.isPending ? 'Discarding...' : 'Discard All Changes'}
+              </button>
+            </div>
+          </div>
+        </div>
+      )}
     </div>
   );
 }

frontend/src/components/dashboard/FileTree.tsx

···
-import { useState } from 'react';
+import { useState, useRef, useEffect } from 'react';
 import type { FileNode } from '../../lib/types/api';
 
 interface FileTreeProps {
   files: FileNode[];
   selectedFile: string | null;
   onSelectFile: (path: string) => void;
+  owner: string;
+  repo: string;
+  onCreateFile?: (parentPath: string) => void;
+  onCreateFolder?: (parentPath: string) => void;
+  onRename?: (oldPath: string, newName: string) => void;
 }
 
-export function FileTree({ files, selectedFile, onSelectFile }: FileTreeProps) {
+export function FileTree({
+  files,
+  selectedFile,
+  onSelectFile,
+  owner,
+  repo,
+  onCreateFile,
+  onCreateFolder,
+  onRename,
+}: FileTreeProps) {
   return (
     <div className="p-4 space-y-1">
       {files.length === 0 ? (
···
             selectedFile={selectedFile}
             onSelectFile={onSelectFile}
             level={0}
+            owner={owner}
+            repo={repo}
+            onCreateFile={onCreateFile}
+            onCreateFolder={onCreateFolder}
+            onRename={onRename}
           />
         ))
       )}
···
   selectedFile: string | null;
   onSelectFile: (path: string) => void;
   level: number;
+  owner: string;
+  repo: string;
+  onCreateFile?: (parentPath: string) => void;
+  onCreateFolder?: (parentPath: string) => void;
+  onRename?: (oldPath: string, newName: string) => void;
 }
 
-function FileTreeNode({ node, selectedFile, onSelectFile, level }: FileTreeNodeProps) {
+function FileTreeNode({
+  node,
+  selectedFile,
+  onSelectFile,
+  level,
+  owner,
+  repo,
+  onCreateFile,
+  onCreateFolder,
+  onRename,
+}: FileTreeNodeProps) {
   const [isExpanded, setIsExpanded] = useState(true);
+  const [showActions, setShowActions] = useState(false);
+  const [isRenaming, setIsRenaming] = useState(false);
+  const [renameValue, setRenameValue] = useState(node.name);
+  const renameInputRef = useRef<HTMLInputElement>(null);
   const isSelected = selectedFile === node.path;
 
+  useEffect(() => {
+    if (isRenaming && renameInputRef.current) {
+      renameInputRef.current.focus();
+      renameInputRef.current.select();
+    }
+  }, [isRenaming]);
+
+  const handleRenameSubmit = () => {
+    if (renameValue.trim() && renameValue !== node.name && onRename) {
+      // Replace spaces with hyphens
+      let sanitizedName = renameValue.trim().replace(/\s+/g, '-');
+      
+      // For files, ensure .md extension if not present
+      if (node.type === 'file' && !sanitizedName.endsWith('.md') && !sanitizedName.endsWith('.mdx')) {
+        sanitizedName += '.md';
+      }
+      
+      onRename(node.path, sanitizedName);
+    }
+    setIsRenaming(false);
+    setRenameValue(node.name);
+  };
+
+  const handleRenameCancel = () => {
+    setIsRenaming(false);
+    setRenameValue(node.name);
+  };
+
+  const handleKeyDown = (e: React.KeyboardEvent) => {
+    if (e.key === 'Enter') {
+      handleRenameSubmit();
+    } else if (e.key === 'Escape') {
+      handleRenameCancel();
+    }
+  };
+
   if (node.type === 'file') {
     return (
-      <button
-        onClick={() => onSelectFile(node.path)}
-        className={`
-          w-full text-left px-3 py-2 rounded text-sm flex items-center gap-2
-          transition-colors
-          ${isSelected
-            ? 'bg-gray-900 text-white font-medium'
-            : 'text-gray-700 hover:bg-gray-100'
-          }
-        `}
-        style={{ paddingLeft: `${(level + 1) * 12 + 12}px` }}
+      <div
+        className="group relative"
+        onMouseEnter={() => setShowActions(true)}
+        onMouseLeave={() => setShowActions(false)}
       >
-        <svg className="w-4 h-4 flex-shrink-0" fill="none" viewBox="0 0 24 24" stroke="currentColor">
-          <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z" />
-        </svg>
-        <span className="truncate">{node.name}</span>
-      </button>
+        {isRenaming ? (
+          <div
+            className="flex items-center gap-2 px-3 py-2"
+            style={{ paddingLeft: `${(level + 1) * 12 + 12}px` }}
+          >
+            <svg className="w-4 h-4 flex-shrink-0 text-gray-500" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z" />
+            </svg>
+            <input
+              ref={renameInputRef}
+              type="text"
+              value={renameValue}
+              onChange={(e) => setRenameValue(e.target.value)}
+              onKeyDown={handleKeyDown}
+              onBlur={handleRenameSubmit}
+              className="flex-1 px-2 py-1 text-sm border border-gray-300 rounded focus:outline-none focus:ring-2 focus:ring-gray-900"
+            />
+          </div>
+        ) : (
+          <button
+            onClick={() => onSelectFile(node.path)}
+            className={`
+              w-full text-left px-3 py-2 rounded text-sm flex items-center gap-2
+              transition-colors
+              ${isSelected
+                ? 'bg-gray-900 text-white font-medium'
+                : 'text-gray-700 hover:bg-gray-100'
+              }
+            `}
+            style={{ paddingLeft: `${(level + 1) * 12 + 12}px` }}
+          >
+            <svg className="w-4 h-4 flex-shrink-0" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z" />
+            </svg>
+            <span className="truncate">{node.name}</span>
+          </button>
+        )}
+
+        {/* Actions menu for files */}
+        {showActions && !isRenaming && (
+          <div className="absolute right-2 top-1/2 -translate-y-1/2 flex items-center gap-1">
+            <button
+              onClick={(e) => {
+                e.stopPropagation();
+                setIsRenaming(true);
+              }}
+              className="p-1 rounded hover:bg-gray-200 text-gray-500 hover:text-gray-700"
+              title="Rename file"
+            >
+              <svg className="w-3.5 h-3.5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M11 5H6a2 2 0 00-2 2v11a2 2 0 002 2h11a2 2 0 002-2v-5m-1.414-9.414a2 2 0 112.828 2.828L11.828 15H9v-2.828l8.586-8.586z" />
+              </svg>
+            </button>
+          </div>
+        )}
+      </div>
     );
   }
 
   return (
     <div>
-      <button
-        onClick={() => setIsExpanded(!isExpanded)}
-        className="w-full text-left px-3 py-2 rounded text-sm flex items-center gap-2 text-gray-700 hover:bg-gray-100 font-medium"
-        style={{ paddingLeft: `${level * 12 + 12}px` }}
+      <div
+        className="group relative"
+        onMouseEnter={() => setShowActions(true)}
+        onMouseLeave={() => setShowActions(false)}
       >
-        <svg
-          className={`w-4 h-4 flex-shrink-0 transition-transform ${isExpanded ? 'rotate-90' : ''}`}
-          fill="none"
-          viewBox="0 0 24 24"
-          stroke="currentColor"
-        >
-          <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 5l7 7-7 7" />
-        </svg>
-        <svg className="w-4 h-4 flex-shrink-0" fill="none" viewBox="0 0 24 24" stroke="currentColor">
-          <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M3 7v10a2 2 0 002 2h14a2 2 0 002-2V9a2 2 0 00-2-2h-6l-2-2H5a2 2 0 00-2 2z" />
-        </svg>
-        <span className="truncate">{node.name}</span>
-      </button>
+        {isRenaming ? (
+          <div
+            className="flex items-center gap-2 px-3 py-2"
+            style={{ paddingLeft: `${level * 12 + 12}px` }}
+          >
+            <svg
+              className={`w-4 h-4 flex-shrink-0 text-gray-500 transition-transform ${isExpanded ? 'rotate-90' : ''}`}
+              fill="none"
+              viewBox="0 0 24 24"
+              stroke="currentColor"
+            >
+              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 5l7 7-7 7" />
+            </svg>
+            <svg className="w-4 h-4 flex-shrink-0 text-gray-500" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M3 7v10a2 2 0 002 2h14a2 2 0 002-2V9a2 2 0 00-2-2h-6l-2-2H5a2 2 0 00-2 2z" />
+            </svg>
+            <input
+              ref={renameInputRef}
+              type="text"
+              value={renameValue}
+              onChange={(e) => setRenameValue(e.target.value)}
+              onKeyDown={handleKeyDown}
+              onBlur={handleRenameSubmit}
+              className="flex-1 px-2 py-1 text-sm border border-gray-300 rounded focus:outline-none focus:ring-2 focus:ring-gray-900"
+            />
+          </div>
+        ) : (
+          <button
+            onClick={() => setIsExpanded(!isExpanded)}
+            className="w-full text-left px-3 py-2 rounded text-sm flex items-center gap-2 text-gray-700 hover:bg-gray-100 font-medium"
+            style={{ paddingLeft: `${level * 12 + 12}px` }}
+          >
+            <svg
+              className={`w-4 h-4 flex-shrink-0 transition-transform ${isExpanded ? 'rotate-90' : ''}`}
+              fill="none"
+              viewBox="0 0 24 24"
+              stroke="currentColor"
+            >
+              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 5l7 7-7 7" />
+            </svg>
+            <svg className="w-4 h-4 flex-shrink-0" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M3 7v10a2 2 0 002 2h14a2 2 0 002-2V9a2 2 0 00-2-2h-6l-2-2H5a2 2 0 00-2 2z" />
+            </svg>
+            <span className="truncate">{node.name}</span>
+          </button>
+        )}
+
+        {/* Actions menu for folders */}
+        {showActions && !isRenaming && (
+          <div className="absolute right-2 top-1/2 -translate-y-1/2 flex items-center gap-1">
+            <button
+              onClick={(e) => {
+                e.stopPropagation();
+                onCreateFile?.(node.path);
+              }}
+              className="p-1 rounded hover:bg-gray-200 text-gray-500 hover:text-gray-700"
+              title="Add file"
+            >
+              <svg className="w-3.5 h-3.5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z" />
+              </svg>
+            </button>
+            <button
+              onClick={(e) => {
+                e.stopPropagation();
+                onCreateFolder?.(node.path);
+              }}
+              className="p-1 rounded hover:bg-gray-200 text-gray-500 hover:text-gray-700"
+              title="Add folder"
+            >
+              <svg className="w-3.5 h-3.5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M3 7v10a2 2 0 002 2h14a2 2 0 002-2V9a2 2 0 00-2-2h-6l-2-2H5a2 2 0 00-2 2z" />
+              </svg>
+            </button>
+            <button
+              onClick={(e) => {
+                e.stopPropagation();
+                setIsRenaming(true);
+              }}
+              className="p-1 rounded hover:bg-gray-200 text-gray-500 hover:text-gray-700"
+              title="Rename folder"
+            >
+              <svg className="w-3.5 h-3.5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M11 5H6a2 2 0 00-2 2v11a2 2 0 002 2h11a2 2 0 002-2v-5m-1.414-9.414a2 2 0 112.828 2.828L11.828 15H9v-2.828l8.586-8.586z" />
+              </svg>
+            </button>
+          </div>
+        )}
+      </div>
+
       {isExpanded && node.children && (
         <div>
           {node.children.map((child) => (
···
               selectedFile={selectedFile}
               onSelectFile={onSelectFile}
               level={level + 1}
+              owner={owner}
+              repo={repo}
+              onCreateFile={onCreateFile}
+              onCreateFolder={onCreateFolder}
+              onRename={onRename}
             />
           ))}
         </div>

frontend/src/lib/api/branch.ts

···
   commit_message: string;
   pr_title?: string;
   pr_description?: string;
-  files: string[];
+  files?: string[];
 }
 
 export interface PullRequest {

frontend/src/lib/api/repos.ts

···
     const { data } = await apiClient.delete<{ invalidated_count: number }>(`/api/repos/${owner}/${repo}/cache`);
     return data;
   },
+
+  createFile: async (
+    owner: string,
+    repo: string,
+    path: string,
+    content: string = '',
+    message?: string
+  ): Promise<{ success: boolean; path: string }> => {
+    const { data } = await apiClient.post<{ success: boolean; path: string }>(
+      `/api/repos/${owner}/${repo}/create-file`,
+      { path, content, message }
+    );
+    return data;
+  },
+
+  createFolder: async (
+    owner: string,
+    repo: string,
+    path: string,
+    message?: string
+  ): Promise<{ success: boolean; path: string }> => {
+    const { data } = await apiClient.post<{ success: boolean; path: string }>(
+      `/api/repos/${owner}/${repo}/create-folder`,
+      { path, message }
+    );
+    return data;
+  },
+
+  renameItem: async (
+    owner: string,
+    repo: string,
+    oldPath: string,
+    newPath: string,
+    message?: string
+  ): Promise<{ success: boolean; old_path: string; new_path: string }> => {
+    const { data } = await apiClient.post<{ success: boolean; old_path: string; new_path: string }>(
+      `/api/repos/${owner}/${repo}/rename`,
+      { old_path: oldPath, new_path: newPath, message }
+    );
+    return data;
+  },
+
+  getPendingChanges: async (
+    owner: string,
+    repo: string
+  ): Promise<{ pending_changes: any[]; count: number }> => {
+    const { data } = await apiClient.get<{ pending_changes: any[]; count: number }>(
+      `/api/repos/${owner}/${repo}/pending-changes`
+    );
+    return data;
+  },
+
+  discardChanges: async (
+    owner: string,
+    repo: string
+  ): Promise<{ success: boolean; message: string }> => {
+    const { data } = await apiClient.delete<{ success: boolean; message: string }>(
+      `/api/repos/${owner}/${repo}/pending-changes`
+    );
+    return data;
+  },
 };

frontend/src/lib/hooks/useBranch.ts

···
   return useMutation({
     mutationFn: (params: PublishParams) => branchApi.publish(params),
     onSuccess: (_, variables) => {
-      // Invalidate branch status and file content queries
+      // Invalidate branch status, file content, and pending changes queries
       queryClient.invalidateQueries({
         queryKey: ['branchStatus', variables.owner, variables.repo],
       });
       queryClient.invalidateQueries({
         queryKey: ['fileContent'],
+      });
+      queryClient.invalidateQueries({
+        queryKey: ['pending-changes', variables.owner, variables.repo],
+      });
+      queryClient.invalidateQueries({
+        queryKey: ['files', variables.owner, variables.repo],
       });
     },
   });

frontend/src/lib/hooks/useRepos.ts

···
-import { useQuery } from '@tanstack/react-query';
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
 import { reposApi } from '../api';
 
 export function useRepositories(sortBy: 'updated' | 'created' | 'name' = 'updated') {
···
     enabled: !!owner && !!repo && !!path,
   });
 }
+
+export function useCreateFile(owner: string, repo: string) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: ({ path, content, message }: { path: string; content?: string; message?: string }) =>
+      reposApi.createFile(owner, repo, path, content, message),
+    onSuccess: () => {
+      // Invalidate and refetch files query and pending changes
+      queryClient.invalidateQueries({ queryKey: ['files', owner, repo] });
+      queryClient.invalidateQueries({ queryKey: ['pending-changes', owner, repo] });
+    },
+  });
+}
+
+export function useCreateFolder(owner: string, repo: string) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: ({ path, message }: { path: string; message?: string }) =>
+      reposApi.createFolder(owner, repo, path, message),
+    onSuccess: () => {
+      // Invalidate and refetch files query and pending changes
+      queryClient.invalidateQueries({ queryKey: ['files', owner, repo] });
+      queryClient.invalidateQueries({ queryKey: ['pending-changes', owner, repo] });
+    },
+  });
+}
+
+export function useRenameItem(owner: string, repo: string) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: ({ oldPath, newPath, message }: { oldPath: string; newPath: string; message?: string }) =>
+      reposApi.renameItem(owner, repo, oldPath, newPath, message),
+    onSuccess: () => {
+      // Invalidate and refetch files query and pending changes
+      queryClient.invalidateQueries({ queryKey: ['files', owner, repo] });
+      queryClient.invalidateQueries({ queryKey: ['pending-changes', owner, repo] });
+    },
+  });
+}
+
+export function usePendingChanges(owner: string, repo: string) {
+  return useQuery({
+    queryKey: ['pending-changes', owner, repo],
+    queryFn: () => reposApi.getPendingChanges(owner, repo),
+    enabled: !!owner && !!repo,
+    refetchInterval: 5000, // Refetch every 5 seconds to keep in sync
+  });
+}
+
+export function useDiscardChanges(owner: string, repo: string) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: () => reposApi.discardChanges(owner, repo),
+    onSuccess: () => {
+      // Invalidate and refetch all related queries
+      queryClient.invalidateQueries({ queryKey: ['pending-changes', owner, repo] });
+      queryClient.invalidateQueries({ queryKey: ['files', owner, repo] });
+      queryClient.invalidateQueries({ queryKey: ['branchStatus', owner, repo] });
+    },
+  });
+}